1. HashMap存储每对键和值作为一个Entry<K，V>对象。例如，给出一个HashMap，
Map<String,Integer> aMap = new HashMap<String,Integer>();
键的每次插入，都会有值对应到散列映射上，生成一个Entry <K，V>对象。
通过使用这个Entry <K，V>对象，我们可以根据值来排序HashMap。
2.创建一个简单的HashMap，并插入一些键和值。
ap<String,Integer> aMap = new HashMap<String,Integer>();  
// adding keys and values      
aMap.put("Five", 5);        
aMap.put("Seven", 7);      
aMap.put("Eight", 8);        
aMap.put("One",1);        
aMap.put("Two",2);        
aMap.put("Three", 3);
3.从HashMap恢复entry集合，如下所示。
Set<Entry<String,Integer>> mapEntries = aMap.entrySet();
4.从上述mapEntries创建LinkedList。我们将排序这个链表来解决顺序问题。
我们之所以要使用链表来实现这个目的，是因为在链表中插入元素比数组列表更快。
List<Entry<String,Integer>> aList = new LinkedList<Entry<String,Integer>>(mapEntries);
5.通过传递链表和自定义比较器来使用Collections.sort()方法排序链表。
Collections.sort(aList, new Comparator<Entry<String,Integer>>() {            
        public int compare(Entry<String, Integer> ele1,                    
                Entry<String, Integer> ele2) {               
        return ele1.getValue().compareTo(ele2.getValue());           
        }        
});
6.使用自定义比较器，基于entry的值（Entry.getValue()），来排序链表。
7. ele1.getValue(). compareTo(ele2.getValue())——比较这两个值，
返回0——如果这两个值完全相同的话；返回1——如果第一个值大于第二个值；
返回-1——如果第一个值小于第二个值。
8. Collections.sort()是一个内置方法，仅排序值的列表。它在Collections类中重载。
这两种个方法是
public static <T extends Comparable<? super T>> void sort(List<T> list)
public static <T> void sort(List<T> list, Comparator<? super T> c)
9.现在你已经排序链表，我们需要存储键和值信息对到新的映射中。由于HashMap不保持顺序，因此我们要使用LinkedHashMap。
// Storing the list into Linked HashMap to preserve the order of insertion.      
Map<String,Integer> aMap2 = new LinkedHashMap<String, Integer>();        
        for(Entry<String,Integer> entry: aList) {           
                aMap2.put(entry.getKey(), entry.getValue());      
}
10.完整的代码如下。

1. import java.util.Collections;
   
2. import java.util.Comparator;
   
3. import java.util.HashMap;
   
4. import java.util.LinkedHashMap;
   
5. import java.util.LinkedList;
   
6. import java.util.List;
   
7. import java.util.Map;
   
8. import java.util.Map.Entry;
   
9. import java.util.Set;
   
10. 
    
11. public class HashMapDemo {
    
12. 
    
13.         /**
    
14.          * @param args
    
15.          */
    
16.         public static void main(String[] args) {
    
17.                 // TODO Auto-generated method stub
    
18.                 Map<String, Integer> aMap = new HashMap<String, Integer>();
    
19.                 // adding keys and values
    
20.                 aMap.put("Five", 5);
    
21.                 aMap.put("Seven", 7);
    
22.                 aMap.put("Eight", 8);
    
23.                 aMap.put("One", 1);
    
24.                 aMap.put("Two", 2);
    
25.                 aMap.put("Three", 3);
    
26.                 sortMapByValues(aMap);
    
27.         }
    
28. 
    
29.         private static void sortMapByValues(Map<String, Integer> aMap) {
    
30.                 Set<Entry<String, Integer>> mapEntries = aMap.entrySet();
    
31.                 System.out.println("Values and Keys before sorting ");
    
32.                 for (Entry<String, Integer> entry : mapEntries) {
    
33.                         System.out.println(entry.getValue() + " - " + entry.getKey());
    
34.                 }
    
35.                 // used linked list to sort, because insertion of elements in linked
    
36.                 // list is faster than an array list. List<Entry<String,Integer>> aList
    
37.                 // = new LinkedList<Entry<String,Integer>>(mapEntries);
    
38.                 // sorting the List
    
39.                 Collections.sort(aList, new Comparator<Entry<String, Integer>>() {
    
40.                         @Override
    
41.                         public int compare(Entry<String, Integer> ele1,
    
42.                                         Entry<String, Integer> ele2) {
    
43.                                 return ele1.getValue().compareTo(ele2.getValue());
    
44.                         }
    
45.                 });
    
46.                 // Storing the list into Linked HashMap to preserve the order of
    
47.                 // insertion.
    
48.                 Map<String, Integer> aMap2 = new LinkedHashMap<String, Integer>();
    
49.                 for (Entry<String, Integer> entry : aList) {
    
50.                         aMap2.put(entry.getKey(), entry.getValue());
    
51.                 } // printing values after soring of map
    
52.                 System.out.println("Value " + " - " + "Key");
    
53.                 for (Entry<String, Integer> entry : aMap2.entrySet()) {
    
54.                         System.out.println(entry.getValue() + " - " + entry.getKey());
    
55.                 }
    
56.         }
    
57. 
    
58. }

复制代码

为什么这样子，可以用treeMap么？

看不懂。。。。。。。。

有点晕  既然最后用到了 LinkedHashMap
为什么不直接用TreeMap呢？

看起来还挺麻烦的

看着好专业的样子，不懂，看来路漫漫啊