Map按照Value值进行排序

1  TreeMap按照value进行排序

[java] view plaincopy

1. public class Testing {  
2.   
3.     public static void main(String[] args) {  
4.   
5.         HashMap<String,Double> map = new HashMap<String,Double>();  
6.         ValueComparator bvc =  new ValueComparator(map);  
7.         TreeMap<String,Double> sorted_map = new TreeMap<String,Double>(bvc);  
8.   
9.         map.put("A",99.5);  
10.         map.put("B",67.4);  
11.         map.put("C",67.4);  
12.         map.put("D",67.3);  
13.   
14.         System.out.println("unsorted map: "+map);  
15.   
16.         sorted_map.putAll(map);  
17.   
18.         System.out.println("results: "+sorted_map);  
19.     }  
20. }  
21.   
22. class ValueComparator implements Comparator<String> {  
23.   
24.     Map<String, Double> base;  
25.     public ValueComparator(Map<String, Double> base) {  
26.         this.base = base;  
27.     }  
28.   
29.     // Note: this comparator imposes orderings that are inconsistent with equals.      
30.     public int compare(String a, String b) {  
31.         if (base.get(a) >= base.get(b)) {  
32.             return -1;  
33.         } else {  
34.             return 1;  
35.         } // returning 0 would merge keys  
36.     }  
37. }  

 输出结果

[java] view plaincopy

1. unsorted map: {D=67.3, A=99.5, B=67.4, C=67.4}  
2.   results: {D=67.3, B=67.4, C=67.4, A=99.5}  

2.HashMap按值进行排序

[java] view plaincopy

1. public class MapUtil  
2. {  
3.     public static <K, V extends Comparable<? super V>> Map<K, V>   
4.         sortByValue( Map<K, V> map )  
5.     {  
6.         List<Map.Entry<K, V>> list =  
7.             new LinkedList<Map.Entry<K, V>>( map.entrySet() );  
8.         Collections.sort( list, new Comparator<Map.Entry<K, V>>()  
9.         {  
10.             public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 )  
11.             {  
12.                 return (o1.getValue()).compareTo( o2.getValue() );  
13.             }  
14.         } );  
15.   
16.         Map<K, V> result = new LinkedHashMap<K, V>();  
17.         for (Map.Entry<K, V> entry : list)  
18.         {  
19.             result.put( entry.getKey(), entry.getValue() );  
20.         }  
21.         return result;  
22.     }  
23. }  
24. 
    
25. 
    
26. 
    
27. [java] view plaincopy
    1. Map<String, Integer> map = new HashMap<String, Integer>();  
    2. map.put("d", 2);  
    3. map.put("c", 1);  
    4. map.put("b", 1);  
    5. map.put("a", 3);  
    6.   
    7. List<Map.Entry<String, Integer>> infoIds =  
    8.     new ArrayList<Map.Entry<String, Integer>>(map.entrySet());  
    9.   
    10. //排序前  
    11. for (int i = 0; i < infoIds.size(); i++) {  
    12.     String id = infoIds.get(i).toString();  
    13.     System.out.println(id);  
    14. }  
    15. //d 2  
    16. //c 1  
    17. //b 1  
    18. //a 3  
    19.   
    20. //排序  
    21. Collections.sort(infoIds, new Comparator<Map.Entry<String, Integer>>() {     
    22.     public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {        
    23.         //return (o2.getValue() - o1.getValue());   
    24.         return (o1.getKey()).toString().compareTo(o2.getKey());  
    25.     }  
    26. });   
    27.   
    28. //排序后  
    29. for (int i = 0; i < infoIds.size(); i++) {  
    30.     String id = infoIds.get(i).toString();  
    31.     System.out.println(id);  
    32. }  
    33. //根据key排序  
    34. //a 3  
    35. //b 1  
    36. //c 1  
    37. //d 2  
    38. //根据value排序  
    39. //a 3  
    40. //d 2  
    41. //b 1  
    42. //c 1