java List 倒序排序

package com.shiyu.client.frame.utils;

import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * Created by Administrator on 2017/1/3.
 */
public class CountSortList {


    /**
     * list倒序排序
     * @param strs
     * @return
     */
    public static List<String> countStr(List<String> strs) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        Set<String> set = new HashSet<String>(strs);
        for (String str : set) {
            for (String lstr : strs) {
                if (str.equals(lstr)) {
                    if (map.containsKey(str)) {
                        Integer count = map.get(str);
                        count++;
                        map.put(str, count);
                    } else {
                        map.put(str, 1);
                    }
                }
            }
        }
        strs.clear();
        Map<String, Integer> sortMap = sortMapByValue(map);
        for (Map.Entry<String, Integer> entry : sortMap.entrySet()) {
            strs.add(entry.getKey());
        }
        return strs;
    }

    /**
     * Map倒序排序
     * @param map
     * @return
     */
    private static Map<String, Integer> sortMapByValue(Map<String, Integer> map) {
        List<Map.Entry<String, Integer>> mapList = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
        Collections.sort(mapList, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                return o2.getValue() - o1.getValue();
            }
        });
        Map<String, Integer> result = new LinkedHashMap<String, Integer>();
        for (Map.Entry<String, Integer> entry : mapList) {
            result.put(entry.getKey(), entry.getValue());
        }

        return result;
    }


    public Map<String, String> sortMapByKey(Map<String, String> oriMap) {
        if (oriMap == null || oriMap.isEmpty()) {
            return null;
        }
        Map<String, String> sortedMap = new TreeMap<String, String>(  new Comparator<String>() {
                    public int compare(String key1, String key2) {
                        int intKey1 = 0, intKey2 = 0;
                        try {
                            intKey1 = getInt(key1);
                            intKey2 = getInt(key2);
                        } catch (Exception e) {
                            intKey1 = 0;
                            intKey2 = 0;
                        }
                        return intKey1 - intKey2;
                    }
                });
        sortedMap.putAll(oriMap);
        return sortedMap;
    }

    private int getInt(String str) {
        int i = 0;
        try {
            Pattern p = Pattern.compile("^\\d+");
            Matcher m = p.matcher(str);
            if (m.find()) {
                i = Integer.valueOf(m.group());
            }
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
        return i;
    }



    public static void main(String[] args) {
        List<String> strs = Arrays.asList("a", "b", "c", "d", "e", "a", "a",
                "a", "a", "b", "b", "b");
        Map<String, Integer> map = new HashMap<String, Integer>();
        Set<String> set = new HashSet<String>(strs);
        for (String str : set) {
            for (String lstr : strs) {
                if (str.equals(lstr)) {
                    if (map.containsKey(str)) {
                        Integer count = map.get(str);
                        count++;
                        map.put(str, count);
                    } else {
                        map.put(str, 1);
                    }

                }
            }
        }
        Map<String, Integer> sortMap = sortMapByValue(map);
        for (Map.Entry<String, Integer> entry : sortMap.entrySet()) {
            System.out.println("Key : " + entry.getKey() + " Value : "
                    + entry.getValue());
        }
    }
}