字符串出现次数排序

四种方式的执行时间比例大概是 100：50：15：12

/**
* Lambda+stream 排序
*/
public List<String> useLambdaStream(){
    List<String> strList = Arrays.asList("a,b,cc,b,b,cc".split(","));
    //
    Map<String, Long> sortMap = strList.stream().collect(Collectors.groupingBy(t -> t, Collectors.counting()));
    List<String> sortList = strList.stream().distinct().collect(Collectors.toList());
    sortList.sort((t1, t2) -> (int) (sortMap.get(t2) - sortMap.get(t1)));
    return sortList;
}

/**
* Lambda 排序
*/
public List<String> useLambda() {
    List<String> strList = Arrays.asList("a,b,cc,b,b,cc".split(","));
    //
    Map<String, Integer> sortMap = new HashMap<>();
    for (String s : strList) {
        Integer count = sortMap.get(s);
        if (null != count) {
            sortMap.put(s, count + 1);
        } else {
            sortMap.put(s, 1);
        }
    }
    //
    List<Entry<String, Integer>> entryList = new ArrayList<>(sortMap.entrySet());
    entryList.sort((t1, t2) -> t2.getValue() - t1.getValue());
    //
    List<String> listResult = new ArrayList<>();
    for (Entry<String, Integer> mapping : entryList) {
        listResult.add(mapping.getKey());
    }
    return listResult;
}

/**
* Comparator 排序
*/
public List<String> useComparator() {
    List<String> strList = Arrays.asList("a,b,cc,b,b,cc".split(","));
    //
    Map<String, Integer> map = new TreeMap<String, Integer>();
    for (String key : strList) {
        Integer value = map.get(key);
        if (null == value) {
            map.put(key, 1);
        } else {
            map.put(key, value + 1);
        }
    }
    //
    List<Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
    Collections.sort(list, new Comparator<Entry<String, Integer>>() {
        @Override
        public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
            return o2.getValue().compareTo(o1.getValue());
        }
    });
    //
    List<String> listResult = new ArrayList<>();
    for (Entry<String, Integer> mapping : list) {
        listResult.add(mapping.getKey());
    }
    return listResult;
}

/**
* Comparable 排序
*/
public List<String> useComparable(){
    List<String> strList = Arrays.asList("a,b,cc,b,b,cc".split(","));
    //
    List<OrderAssist> listOrder = new ArrayList<>();
    for(String s : strList){
        OrderAssist tmp = new OrderAssist(s, 1);
        if(listOrder.contains(tmp)){
            listOrder.get(listOrder.indexOf(tmp)).count++;
        }else{
            listOrder.add(tmp);
        }
    }
    Collections.sort(listOrder);
    //
    List<String> listResult = new ArrayList<>();
    for(OrderAssist object : listOrder){
        listResult.add(object.name);
    }
    return listResult;
}

//comparable辅助类
class OrderAssist implements Comparable<OrderAssist>{
    public String name;
    public int count;
    
    public OrderAssist(String name, int count){
        this.name = name;
        this.count = count;
    }
    @Override
    public boolean equals(Object object){
        return this.name.equals(((OrderAssist)object).name);
    }
    @Override
    public int compareTo(OrderAssist entity) {
        return entity.count - count;
    }
}