Map根据value排序ASC DESC

原文：http://blog.csdn.net/k21325/article/details/53259180

需求有点刁钻，写关键词组合匹配标题的时候，遇到关键词像这样

XXX XXX 1222
XXX XXX 222
XXX XXX 22
XXX XXX 22
XXX XXX 11
XXX XXX 1
XXX XXX 1

前面的XXX 代表关键词，两两组合，后面的数字代表优先级，优先级高的优先匹配

那么问题来了，每匹配到一个词组，要提取出来，作为新的匹配词组表，这个步骤就肯定了顺序是乱的，且有重复，

通过Set去重之后，我们的需求是这样，要按照后面的优先级排序，优先级高的在前面

这时候我就想到了要用Map放Key Value，问题就在这，key不能放优先级的数字，因为有重复值，而整条匹配词组是没有重复值的，so，map值就编程了这样

["XXX XXX 1222":1222,"XXX XXX 222":222,...]  

重点就在这了，根据map的value值给map排序

/**
     * HashSet <"XX XX 123"> 根据123排序
     * @param hashSet 
     * @param sort 排序方式 "ASC","DESC"
     * @return 排序好的List
     */
    private List<String> sortHashSet2List(HashSet<String> hashSet, String sort){
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (String keyword : hashSet) {
            Integer i = keyword.lastIndexOf(" ")+1;
            Integer l = keyword.length();
            String o = keyword.substring(i,l);
            Integer a = Integer.valueOf(o);
            map.put(keyword, a);
        }
        map = sortByValue(map, sort);
        List<String> list = new ArrayList<String>();
        for(Entry<String, Integer> entry:map.entrySet()){    
            list.add(entry.getKey());
        }   
        return list;
    }
    /**
     * HashMap按值进行排序
     * @param map Map<String,Integer>
     * @param sort 排序 ASC正序/DESC倒序
     * @return map <String,Integer>
     */
    private static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map,String sort) {
        
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });
        Map<K, V> result = new LinkedHashMap<K, V>();
        if("ASC".equals(sort)){
            for (int i = list.size()-1; i >=0; i--) {
                result.put(list.get(i).getKey(), list.get(i).getValue());
            }
        }
        if("DESC".equals(sort)){
            for (Map.Entry<K, V> entry : list) {
                result.put(entry.getKey(), entry.getValue());
            }
        }
        return result;
    }