由多到少依次输出元素的出现次数。下面每一行代码都有对应的标注。另附kotlin版

public class Test {
    public static void main(String args[]) {
        //创建字符串数组
        String[] example = {"abc", "abc", "def", "abc", "def", "aaa"};
        //创建HashMap,保存元素和出现次数
        HashMap<String, Integer> map = new HashMap<>(16);
        //for循环数组，加入元素和出现次数，通过key获取出现次数，没就把出现次数设置为1，而再次出现出现次数就加1。
        for (String str : example) {
            Integer count = map.get(str);
            map.put(str, count == null ? 1 : count + 1);
        }
        //打印元素以及其出现次数
        for (String key : map.keySet()) {
            // System.out.println(key+":"+map.get(key));
        }
        //创建List对象,传入map.entry对象
        List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
        //创建static类ValueComparator，值比较器
        ValueComparator vc = new ValueComparator();
        //调用sort方法排序
        Collections.sort(list, vc);
        //输出大到小排序结果
        for (Map.Entry<String, Integer> m : list) {
            System.out.println(m.getKey() + ":" + m.getValue());
        }
    }
    static class ValueComparator implements Comparator<Map.Entry<String, Integer>> {

        @Override
        public int compare(Map.Entry<String, Integer> m, Map.Entry<String, Integer> n) {
            //小到大的顺序
            // m.getValue()-n.getValue();
            // 大到小的顺序
            return n.getValue() - m.getValue();
        }
    }
}

输出结果：
abc:3
def:2
aaa:1

下面是kotlin 版

class Test2 { 
 fun main(args: Array<String>) {
 val example = arrayOf("abc", "abc", "def", "abc", "def", "aaa")
        val map = HashMap<String, Int>(16)
        for (str in example) {
            val count = map[str]
            map[str] = count?.plus(1) ?: 1
        }
        val list = ArrayList<Map.Entry<String, Int>>()
        list.addAll(map.entries)
        val vc = ValueComparator()
        Collections.sort(list, vc)
        for (entry in list) {
            Log.i("debug=", entry.key + ":" + entry.value)
        }
}
    class ValueComparator : Comparator<Map.Entry<String, Int>> {
        override fun compare(o1: Map.Entry<String, Int>, o2: Map.Entry<String, Int>): Int {
            return o2.value - o1.value
        }

    }