java集合类源码分析之Map（二）

这一节主要讨论Map接口的几个实现类的区别和用法。

1.线程安全

Hashtable是线程安全的（原因与StringBuffer、Vector相似），而其他的Map实现类都是非线程安全的，至于为什么，可以看之前的一些文章，前面已经介绍地很详细了。

这里特别讲解一下HashMap和Hashtable的区别与联系：

• 继承的父类不同。Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。
• 线程安全性不同。
• key和value是否允许null值。 Hashtable中，key和value都不允许出现null值，HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。
• 遍历的实现方式不同。Hashtable、HashMap都实现了 Iterator，而由于历史原因，Hashtable还使用Enumeration的方式 。
• 哈希值不同。Hashtable直接使用对象的hashCode，而HashMap重新计算hash值。
• 数组初始化和扩容方式不同。 Hashtable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。所以，Hashtable扩容时，将容量变为原来的2倍加1(2*old+1)，而HashMap扩容时，将容量变为原来的2倍。

2.适用条件

HashMap：适用于需要快速查找的数据，并且数据无序的情况下，允许键为空（只一次），允许值为空；

TreeMap：适用于按key有序存储的数据，不允许键为空；

Hashtable：适用于有同步要求的情况下，保证线程安全，不允许键和值为空；

LinkedHashMap：保存了元素插入时的顺序，具有HashMap的所有特性，但遍历时比HashMap要慢。

HashMap与LinkedHashMap的比较示例：

    private static void linkedHashMapAnal() {
        //LinkedHashMap具有HashMap的所有特性，并且能够保留元素插入时的顺序
        Map<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
        Map<String, Integer> hashMap = new HashMap<String, Integer>();
        
        hashMap.put("A", 120);
        hashMap.put("B", 100);
        hashMap.put("C", 105);
        hashMap.put("D", 200);
        for(String key: hashMap.keySet()){
            System.out.print(key+":"+hashMap.get(key)+" ");
        }//D:200 A:120 B:100 C:105
        
        System.out.println();
        linkedHashMap.put("A", 120);
        linkedHashMap.put("B", 100);
        linkedHashMap.put("C", 105);
        linkedHashMap.put("D", 200);
        for(String key: linkedHashMap.keySet()){
            System.out.print(key+":"+linkedHashMap.get(key)+" ");
        }//A:120 B:100 C:105 D:200 
    }

3.排序问题

Map集合的排序常常分为按key排序和按value排序。

• 按key排序

有两种方式来实现Map的按key排序：TreeMap中的比较器和Collections类中的sort方法。

1.TreeMap的按key排序

        //采用默认比较器按key值升序排列，进行存储
        Map<String, Integer> treeMap = new TreeMap<String, Integer>();
        treeMap.put("B", 120);
        treeMap.put("C", 105);
        treeMap.put("A", 100);
        for(String key: treeMap.keySet()){
            System.out.print(key+":"+treeMap.get(key)+", ");
        }    //A:100, B:120, C:105, 
    }

        //自定义比较器，实现降序存储
        Map<String, Integer> treeMap = new TreeMap<String, Integer>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
//                return 0; 默认升序
                return o2.compareTo(o1); //降序
            }
        });
        treeMap.put("B", 120);
        treeMap.put("C", 105);
        treeMap.put("A", 100);
        for(String key: treeMap.keySet()){
            System.out.print(key+":"+treeMap.get(key)+", ");
        }    //C:105, B:120, A:100,

        //用SortedMap子集初始化TreeMap对象，调用参数自带的比较器
        //注意：TreeMap初始化的参数必须为SortedMap类型或者其实现类TreeMap类型，否则将调用默认比较器，所以此处也可以创建一个TreeMap类型的subMap
        SortedMap<String, Integer> subMap = new TreeMap<String, Integer>(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                // TODO Auto-generated method stub
                return o2.compareTo(o1);
            }
        });
        subMap.put("B", 100);
        subMap.put("F", 120);
        subMap.put("D", 105);
        for(String key: subMap.keySet()){
            System.out.print(key+":"+subMap.get(key)+", ");
        }    //F:120, D:105, B:100, 
        
        System.out.println();
        
        Map<String, Integer> treeMap = new TreeMap<String, Integer>(subMap);
        for(String key: treeMap.keySet()){
            System.out.print(key+":"+treeMap.get(key)+", ");
        }    //F:120, D:105, B:100, 
        
        System.out.println();
        
        treeMap.put("A", 200);
        treeMap.put("C", 300);
        treeMap.put("E", 400);
        for(String key: treeMap.keySet()){
            System.out.print(key+":"+treeMap.get(key)+", ");
        }    //F:120, E:400, D:105, C:300, B:100, A:200, 

2.HashMap的按key排序

        //用HashMap子集初始化TreeMap对象，调用默认比较器（升序）
         //注意：TreeMap初始化的参数为Map接口的实现类subMap
        Map<String, Integer> subMap = new HashMap<String, Integer>();
        subMap.put("B", 100);
        subMap.put("A", 120);
        subMap.put("C", 105);
        subMap.put("D", 200);
        for(String key: subMap.keySet()){
            System.out.print(key+":"+subMap.get(key)+", ");
        }    //D:200, A:120, B:100, C:105,
        
        System.out.println();
        
        Map<String, Integer> treeMap = new TreeMap<String, Integer>(subMap);        
        for(String key: treeMap.keySet()){
            System.out.print(key+":"+treeMap.get(key)+", ");
        }    //A:120, B:100, C:105, D:200,

        Map<String, Integer> hashMap = new HashMap<String, Integer>();
        
        //hashMap默认按key的哈希值排列，是一种无序存储
        hashMap.put("A", 100);
        hashMap.put("B", 120);
        hashMap.put("C", 105);
        hashMap.put("D", 100);
        for(String key: hashMap.keySet()){
            System.out.print(key+":"+hashMap.get(key)+" ");
        }//D:100 A:100 B:120 C:105   
        
        System.out.println();
        //将HashMap对象存储到List集合中
        ArrayList<Map.Entry<String, Integer>> mapList = new ArrayList<Map.Entry<String, Integer>>(hashMap.entrySet());
        //调用Collections的sort方法，并且重写比较器
        Collections.sort(mapList, new Comparator<Entry<String, Integer>>() {

            @Override
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                // TODO Auto-generated method stub
                return o1.getKey().compareTo(o2.getKey());//升序，按value排序只需将getKey换成getValue即可
//                return o2.getKey().compareTo(o1.getKey());//降序，按value排序只需将getKey换成getValue即可
            }
        } );
        
        for (int i = 0; i < mapList.size(); i++) {
            System.out.print(mapList.get(i).getKey()+":"+mapList.get(i).getValue()+" ");
        }//A:100 B:120 C:105 D:100 

• 按value排序

有了上面的例子，我们知道也可以通过Collections的sort方法来进行Map集合的value排序，包括HashMap和TreeMap。

        Map<String, Integer> hashMap = new HashMap<String, Integer>();
        
        hashMap.put("A", 100);
        hashMap.put("B", 120);
        hashMap.put("C", 105);
        hashMap.put("D", 110);
        for(String key: hashMap.keySet()){
            System.out.print(key+":"+hashMap.get(key)+" ");
        }//D:110 A:100 B:120 C:105    
        
        System.out.println();
        //将HashMap对象存储到List集合中
        ArrayList<Map.Entry<String, Integer>> mapList = new ArrayList<Map.Entry<String, Integer>>(hashMap.entrySet());
        //调用Collections的sort方法，并且重写比较器
        Collections.sort(mapList, new Comparator<Entry<String, Integer>>() {

            @Override
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                // TODO Auto-generated method stub
                return o1.getValue().compareTo(o2.getValue());//升序
//                return o2.getValue().compareTo(o1.getValue());//降序
            }
        } );
        
        for (int i = 0; i < mapList.size(); i++) {
            System.out.print(mapList.get(i).getKey()+":"+mapList.get(i).getValue()+" ");
        }//A:100 C:105 D:110 B:120 

        ArrayList<Map.Entry<String, Integer>> mapList = new ArrayList<Map.Entry<String, Integer>>(treeMap.entrySet());
        Collections.sort(mapList, new Comparator<Entry<String, Integer>>() {

            @Override
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                // TODO Auto-generated method stub
                return o1.getValue().compareTo(o2.getValue());//升序
//                return o2.getValue().compareTo(o1.getValue());//降序
            }
        });
        for (int i = 0; i < mapList.size(); i++) {
            System.out.print(mapList.get(i).getKey()+":"+mapList.get(i).getValue()+" ");
        }//B:100 D:105 F:120 C:300 E:400 A:500 
        
    }

 补充：如何实现HashMap按key降序排列？

• 利用Collections类的sort方法实现：将HashMap存储到一个List中，然后调用Collections.sort()方法，同时重写比较器。
• 利用TreeMap的putAll方法实现：创建一个空的TreeMap对象，同时初始化一个降序的比较器，用putAll方法将HashMap中的元素加入TreeMap对象中。

        Map<String, Integer> hashMap = new HashMap<String, Integer>();
        hashMap.put("A", 100);
        hashMap.put("B", 120);
        hashMap.put("C", 105);
        hashMap.put("F", 110);
        hashMap.put("E", 300);
        hashMap.put("D", 200);
        for(String key: hashMap.keySet()){
            System.out.print(key+":"+hashMap.get(key)+" ");
        }//D:200 E:300 F:110 A:100 B:120 C:105   
        
        System.out.println();
        
        //调用Collections的sort方法，实现HashMap按key降序排列
        ArrayList<Map.Entry<String, Integer>> mapList = new ArrayList<Map.Entry<String, Integer>>(hashMap.entrySet());
        Collections.sort(mapList, new Comparator<Entry<String, Integer >>() {

            @Override
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                // TODO Auto-generated method stub
                return o2.getKey().compareTo(o1.getKey());//降序
            }
        });
        
        for (Iterator iterator = mapList.iterator(); iterator.hasNext();) {
            Entry<String, Integer> entry = (Entry<String, Integer>) iterator.next();
            System.out.print(entry.getKey()+":"+entry.getValue()+" ");
        }//F:110 E:300 D:200 C:105 B:120 A:100

        Map<String, Integer> hashMap = new HashMap<String, Integer>();
        hashMap.put("A", 100);
        hashMap.put("B", 120);
        hashMap.put("C", 105);
        hashMap.put("F", 110);
        hashMap.put("E", 300);
        hashMap.put("D", 200);
        for(String key: hashMap.keySet()){
            System.out.print(key+":"+hashMap.get(key)+" ");
        }//D:200 E:300 F:110 A:100 B:120 C:105   
        
        System.out.println();

        //调用TreeMap的putAll方法，实现HashMap按key降序排列
        Map<String, Integer> treemap = new TreeMap<String, Integer>(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                // TODO Auto-generated method stub
                return o2.compareTo(o1);//降序
            }
        });
        
        treemap.putAll(hashMap);
        for(String key: treemap.keySet()){
            System.out.print(key+":"+treemap.get(key)+" ");
        }//F:110 E:300 D:200 C:105 B:120 A:100 

 至此，Map接口的实现类及其用法比较基本介绍完毕。