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

　　java集合中Map接口的实现类有HashMap、Hashtable、LinkedHashMap和TreeMap，与List不同的是Map并不是继承自Collection接口。可以这样来理解它：

• Map提供key到value的映射，一个Map中不能包含相同的key，每个key只能映射一个 value。
• Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射

 1.HashMap

• HashMap的基本实现为一个链表数组（Entry<K, V>[ ]），即存放链表的数组，数组中的每个元素都是一个链表的头结点，而链表中的基本数据类型是一个静态内部类（Node）的对象，这些对象都具有相同的hash(key)值，所以是一种无序存储。

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

• HashMap 的实例有两个参数影响其性能：初始容量（默认16） 和加载因子（默认0.75）。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子是描述哈希表在扩容之前可以达到多满的一种度量。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。因此，HashMap的容量并不等于能够存储的对象的个数。

• 因此，在创建实例的时候我们要按照自己的需求来设置这两个值，当空间大而对查询效率要求高的时候可以将初始容量设置的大一些，而加载因子小一些这样的话查询效率高，但空间利用率不高，而当空间比较小而效率要求不是很高的时候可以将初始容量设置小一些而加载因子设置大一些，这样查询速度会慢一些而空间利用率会高一些。

• 按照key关键字的哈希值和buckets数组的长度取模（hash(key)%length）查找桶的位置，如果key的哈希值相同，Hash冲突（指向了同一个桶）则每次新添加的作为头节点，而最先添加的在表尾。

　　（参考文章：http://blog.csdn.net/qh_java/article/details/46404439）

　　                        　　                       

图片来源：http://blog.csdn.net/qh_java/article/details/46404439　　　　　

下面通过源码来进行分析，了解HashMap的一些基本用法：

• 构造器（四种）

1.HashMap(int initialCapacity, float loadFactor) 第一个参数为初始容量，第二个参数为加载因子

2.HashMap(int initialCapacity) 只初始化容量，加载因子为默认值0.75

3. HashMap() 空的构造器，加载因子为默认值0.75

4.HashMap(Map<? extends K, ? extends V> m) 初始化HashMap中的元素，加载因子默认0.75

• 插入元素

1.put(K key, V value) 插入单个map元素

2. putAll(Map<? extends K, ? extends V> m) 插入一个map集合

        //hashMap默认按key的哈希值存储，所以是一种无序存储
        hashMap.put("A", 100);
        hashMap.put("B", 120);
        hashMap.put("C", 105);
        for(String key: hashMap.keySet()){
            System.out.print(key+":"+hashMap.get(key)+", ");
        }//A:100, B:120, C:105, 

• 查找元素

1.get(Object key) 按key值查找相应的value值

2.containsKey(Object key) 查找map中是否含有指定的key

3.containsValue(Object value) 查找map中是否含有指定的value

        System.out.println(hashMap.get("A"));//100
        System.out.println(hashMap.containsKey("A"));//true
        System.out.println(hashMap.containsValue(100));//true

• 修改元素

1.put(K key, V value) 找到key值相同的value，用新的value值进行覆盖

        hashMap.put("A", 500);
        System.out.println(hashMap.get("A"));//500

• 删除元素

1.remove(Object key) 按key查找，将相应的key-value对删除，并返回删除的value值

2.clear() 清空所有元素

        System.out.println(hashMap.size());//4
        hashMap.remove("D");
        System.out.println(hashMap.containsKey("D"));//false
        System.out.println(hashMap.size());//3

2.TreeMap

• TreeMap的基本实现是一棵红黑二叉树，按照key值以二叉树的结构进行存储，即当前节点的值大于或等于左孩子节点的值而小于或等于右孩子节点的值，所以TreeMap是一种按key排序的有序存储结构。数据存储的基本形式是一个Entry<K, V>对象，而Entry是TreeMap的一个静态内部类。

    static final class Entry<K,V> implements Map.Entry<K,V> {
        K key;
        V value;
        Entry<K,V> left;
        Entry<K,V> right;
        Entry<K,V> parent;
        boolean color = BLACK;

        /**
         * Make a new cell with given key, value, and parent, and with
         * {@code null} child links, and BLACK color.
         */
        Entry(K key, V value, Entry<K,V> parent) {
            this.key = key;
            this.value = value;
            this.parent = parent;
        }

        /**
         * Returns the key.
         *
         * @return the key
         */
        public K getKey() {
            return key;
        }

        /**
         * Returns the value associated with the key.
         *
         * @return the value associated with the key
         */
        public V getValue() {
            return value;
        }

        /**
         * Replaces the value currently associated with the key with the given
         * value.
         *
         * @return the value associated with the key before this method was
         *         called
         */
        public V setValue(V value) {
            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }

        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;

            return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
        }

        public int hashCode() {
            int keyHash = (key==null ? 0 : key.hashCode());
            int valueHash = (value==null ? 0 : value.hashCode());
            return keyHash ^ valueHash;
        }

        public String toString() {
            return key + "=" + value;
        }
    }

 （关于红黑二叉树的算法和基本操作可以参考：http://www.cnblogs.com/skywang12345/p/3245399.html）

• 构造器（四种）

1.TreeMap() 空的构造器，采用默认的比较器（按key值升序排列）

2.TreeMap(Comparator<? super K> comparator) 参数为自定义的比较器，常用于实现降序排列

3.TreeMap(Map<? extends K, ? extends V> m) 参数为一个map子集，用于初始化TreeMap对象，采用默认比较器

4.TreeMap(SortedMap<K, ? extends V> m) 参数为一个SortedMap集合，用于初始化TreeMap对象，采用参数自带的比较器

应用示例：

                //采用默认比较器按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,

        //初始化TreeMap对象，采用默认比较器进行排序
        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,

        //初始化TreeMap对象，采用参数自带的比较器
        //注意：此处参数必须为SortedMap接口的实现类，否则将采用默认比较器
        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,  

• 插入元素

1.put(K key, V value) 插入一个key-value对，并调整二叉树结构

2.putAll(Map<? extends K, ? extends V> map) 插入一个Map子集

由于红黑二叉树的结构限制，每次插入元素时都需要调整树的结构以保证插入后任然是一颗红黑二叉树，至于红黑二叉树的维持算法此处不做详细介绍。

• 查询元素

1.get(Object key) 按照指定的key值查找相对应的value值

        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,  
        
        System.out.println(treeMap.get("A"));//200

• 修改元素

1.put(K key, V value) 根据key值查找相对应的value值，并用新的value值覆盖

        treeMap.put("A",500);
        System.out.println(treeMap.get("A"));//500

• 删除元素

1.remove(Object key) 按key值删除相对应的键值对，并返回删除的value值

2.clear() 清空所有元素

3.Hashtable

HashMap和Hashtable类似，但是Hashtable是线程安全的（同步机制，原因类似于StringBuffer类和Vector类），并且不允许空的键（key）和值（value）。