[java源码分析]HashMap源码分析

        Hashmap是java中非常常用的容器，在网上看见很多源码分析都是以前版本的，本文章结合JDK1.8的源码对HashMap进行简单的分析，在学习的过程中发现HashMap的源码远比前面的List要复杂的多，花了好长时间才理清关系。

一、基本参数与构造函数

public class HashMap<K,V> extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable {private static final long serialVersionUID = 362498820763181265L;            /* ---------------- Fields -------------- */    //存储节点的table数组，第一次使用的时候初始化，必要时resize，长度总是2的倍数    transient Node<K,V>[] table;    //缓存entrySet，用于keySet() and values()    transient Set<Map.Entry<K,V>> entrySet;    //容器中元素的个数    transient int size;    //每次扩容和更改map结构的计数器    transient int modCount;    //阈值，当实际大小超过阈值时，会进行扩容    int threshold;    //装载因子    final float loadFactor;                //默认的初始容量，必须是2的幂次，出于优化考虑，默认16    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;     //默认的最大容量    static final int MAXIMUM_CAPACITY = 1 << 30;    //默认的装载因子，在无参构造器中默认设为该值    static final float DEFAULT_LOAD_FACTOR = 0.75f;    //阈值，当链表中节点数大于该阈值后就会转变成红黑树    static final int TREEIFY_THRESHOLD = 8;    //与上一个阈值相反，当小于这个阈值后转变回链表    static final int UNTREEIFY_THRESHOLD = 6;    // 看源码注释里说是：树的最小的容量，至少是 4 x TREEIFY_THRESHOLD = 32 然后为了避免(resizing 和 treeification thresholds) 设置成64    static final int MIN_TREEIFY_CAPACITY = 64;    //基本哈希容器节点 实现Map.Entry接口    static class Node<K,V> implements Map.Entry<K,V> {        final int hash;//不可变的哈希值，由关键字key得来        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() {//Node对象的哈希值，关键字key的hashCode()与值value的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) {//对象相同或同类型且key-value均相同，则返回true              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;        }    }        /*     * 构造函数     */        public HashMap(int initialCapacity, float loadFactor) {//给定初始容量和装载因子，构造一个空的HashMap        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal initial capacity: " +                                               initialCapacity);        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " +                                               loadFactor);        this.loadFactor = loadFactor;        this.threshold = tableSizeFor(initialCapacity);//根据指定的容量计算容量，因为必须是2的幂次，虽然将该值赋给threshold，但表示的依然是容量，到时候会重新计算阈值    }    public HashMap(int initialCapacity) {//指定初始容量，和默认装载因子0.75构造空HashMap        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }    public HashMap() {//无参，使用默认的初始容量16,和装载因子0.75构造空的HashMap        this.loadFactor = DEFAULT_LOAD_FACTOR;     }    public HashMap(Map<? extends K, ? extends V> m) {//构造一个和给定Map映射相同的HashMap，默认装载因子，初始空间以足够存放给定Map中的映射为准         this.loadFactor = DEFAULT_LOAD_FACTOR;        putMapEntries(m, false);    }    }

        上面给出了HashMap的定义，和前面的基本参数，内部节点类的定义和4个构造函数。

        

        1、table数组

        该数组类似与一个桶，通过对key值hash运算得到index值，就该节点在数组中的下标，所有index值相同的节点形成链表或者红黑树，而table[index]则指向该链表或者红黑树的头节点。最理想的状态就是每个index中只有一个元素，这样查找一个key的时候，通过O(1)时间计算出index，就可以直接找到该key对应的节点。

        

        2、容量、装载因子和阈值

        个人人为这三个参数是HashMap中最重要的三个参数。

· 容量Capacity，就是table数组的大小，一定是2的倍数。

        在第一次加入元素的时候会通过resize方法来创建该数组。

        如果在构造函数中指定了容量，那么会调用tableSizeFor方法根据这个容量计算出2的幂次的容量，然后将容量赋值给threshold，在初始化的时候在根据threshold得到容量最后再重新计算threshold阈值。

        初始化之后，每次map中元素超过阈值，容量都会*2，知道达到设定的最大重量。

· 阈值threshold。一个临界值，当map中的节点个数超过这个临界值的时候，就要调用resize方法来将table数组扩大2倍，同时阈值也会扩大2倍。

        默认情况下threshold=DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY，之后在每次容量翻倍的时候，阈值也跟着翻倍。

        如果在构造函数中指定了容量，那么会调用tableSizeFor方法来计算然后把计算结构赋值给阈值。最后初始化之后再重新计算阈值。float ft = (float)newCap * loadFactor; 下面来看一下tableSizeFor方法。

    //返回大于指定容量且是2的幂次的值，比如给定999，返回1024    static final int tableSizeFor(int cap) {        int n = cap - 1;        n |= n >>> 1;        n |= n >>> 2;        n |= n >>> 4;        n |= n >>> 8;        n |= n >>> 16;        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;    }

· 装载因子loadFactor。用来计算阈值。举个例子

        如果负载因子是默认的0.75，HashMap(16)的时候，占16个内存空间，实际上只用到了12个，超过12个就扩容。如果负载因子是1的话，HashMap(16)的时候，占16个内存空间，实际上会填满16个以后才会扩容。

        3、构造函数

        一共有4个构造函数，前面三个都是构造一个空的HashMap,可以指定容量和装载因子，或者直接使用默认值。第第四个构造一个和给定Map映射相同的HashMap，默认装载因子，初始空间以足够存放给定Map中的映射为准，调用putMapEntries方法下面再详细分析。

二、关键方法

        个人人为HashMap最关键的两个方法就是hash函数的实现和resize方法。每次put元素的时候都要先调用hash函数来去诶的那个元素存储的位置，而resize方法用于扩大table的容量，下面主要分析这两个方法。

        

        1、hash函数的实现和put过程。

        put方法的完整过程为：

1. 对key的hashCode()做hash，然后再计算index;
2. 如果没碰撞直接放到bucket里；
3. 如果碰撞了，以链表的形式存在buckets后；
4. 如果碰撞导致链表过长(大于等于TREEIFY_THRESHOLD)，就把链表转换成红黑树；
5. 如果节点已经存在就替换old value(保证key的唯一性)
6. 如果bucket满了(超过load factor*current capacity)，就要resize

    public V put(K key, V value) {        return putVal(hash(key), key, value, false, true);    }            static final int hash(Object key) {        int h;        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);    }    /*     * 实现Map.put以及相关方法     * 向map中加入个节点     * 没有分析onlyIfAbsent和evict     */    final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {Node<K, V>[] tab;//指向table数组Node<K, V> p;//对应下标中的第一个节点，为null说明没有碰撞，不为null代表链表第一个元素或红黑树根节点int n, i;//n为table数组的长度，2的幂次; i表示对应的下标indexif ((tab = table) == null || (n = tab.length) == 0) // 如果table为空即第一次添加元素，则进行初始化n = (tab = resize()).length;/* * 计算下标，根据hash与n计算index * 公式:i = (n - 1) & hash; */// p=table[i]; 对应下标中的第一个节点if ((p = tab[i = (n - 1) & hash]) == null) // p为null说明没有碰撞，tab[i] = newNode(hash, key, value, null);//直接新建一个节点加入就可以了else {// p不为null，说明有碰撞Node<K, V> e;//e，代表map中与给定key值相同的节点K k;//代表e的key// p的关键字与要加入的关键字相同，则p就是要找的eif (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))e = p;// 如果p的类型是红黑树，则向红黑树中查找eelse if (p instanceof TreeNode)e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);// 否则就是链表else {for (int binCount = 0;; ++binCount) {//遍历链表查找e，如果找不到就新建一个if ((e = p.next) == null) {// 如果next为null，说明没有找到p.next = newNode(hash, key, value, null);// 那么新创建一个节点if (binCount >= TREEIFY_THRESHOLD - 1) // 加入节点后如果超出树形化阈值treeifyBin(tab, hash);// 则转换为红黑树break;}if (e.hash == hash && // 找到关键字相同的节点，退出循环((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}if (e != null) { //e不为null，说明原来存在对应的key，那么返回原来的值V oldValue = e.value;// 保留原来的值，用于返回if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}//说明新插入了一个节点，返回null++modCount;if (++size > threshold) // 超过临界值，则resizeresize();afterNodeInsertion(evict);return null;}

        可以看出，在调用put(key, value)方法后，会首先调用hash(key)计算出key的hash值。这个方法的作用就是：先得到key的hashcode即一个int型32为的整数，然后将它的高16位不变，低16位和高16为做异或操作，得到key的hash值。

        然后在根据key的hash值计算下标index。计算公式：

i = (n - 1) & hash;

        其中n为table数组的长度，也就是说它肯定是2的幂次，举个例子，加入n=16，那么n-1=15的二进制表示就是0x0000 1111，可以看出，任何一个2的幂次减1后二进制肯定都是这种形式，它的意义在于，任何一个值和它做&操作，得到的结构肯定都在0~(n-1)之间，也就是说计算出来的下标值肯定数组的合法下标。hash函数的计算过程如下图：(图片来源：点击打开链接)

        2、resize方法

        从上面可以看到，每次加入元素时都会判断元素个数是否超出阈值，如果超出阈值就会调用resize方法来进行扩容，它的意义在于使节点均匀分布尽量避免碰撞，这样才能实现较好的查找性能。

    /*     * 第一次加入元素或者size超过阈值的时候都会调用该方法初始化或者扩大table的容量     */    final Node<K,V>[] resize() {        Node<K,V>[] oldTab = table;        int oldCap = (oldTab == null) ? 0 : oldTab.length;        int oldThr = threshold;        int newCap, newThr = 0;                /*         * step1: 先根据容量和阈值确定新的容量和阈值         */                //case1: 如果table已经被初始化，说明不是第一次加入元素        if (oldCap > 0) {                    if (oldCap >= MAXIMUM_CAPACITY) {//如果table的容量已经达到最大值，那么就不再扩容了，碰撞也没办法                threshold = Integer.MAX_VALUE;//那么扩大阈值到最大值                return oldTab;//原来的table不变            }                        //不然的话table的容量扩大2倍，newCap = oldCap << 1            大部分情况下肯定都是这种情况                        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)                newThr = oldThr << 1; //阈值也扩大2倍        }                        //case2: table没有被初始化，但是阈值大于0，说明在构造函数中指定了容量，但是容量存在阈值那个变量上        else if (oldThr > 0)            newCap = oldThr;//那么将阈值设置为table的容量，下面还会重新计算阈值                //case3: table和阈值都没有初始化，说明是无参构造函数        else {                           newCap = DEFAULT_INITIAL_CAPACITY;//使用默认的初始容量            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//计算默认的阈值，threshold=load_factor*capacity        }                //重新计算阈值        if (newThr == 0) {            float ft = (float)newCap * loadFactor;            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?                      (int)ft : Integer.MAX_VALUE);        }                /*         * step2: 更新阈值和新容量的table         */        threshold = newThr;        @SuppressWarnings({"rawtypes","unchecked"})            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];        table = newTab;                        /*         * step3: 如果原来的table中元素，那么把原来的元素加入到新的table中         */                     if (oldTab != null) {            for (int j = 0; j < oldCap; ++j) {                Node<K,V> e;                if ((e = oldTab[j]) != null) {                    oldTab[j] = null;                    if (e.next == null)                        newTab[e.hash & (newCap - 1)] = e;                    else if (e instanceof TreeNode)                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);                    else { // preserve order                        Node<K,V> loHead = null, loTail = null;                        Node<K,V> hiHead = null, hiTail = null;                        Node<K,V> next;                        do {                            next = e.next;                            if ((e.hash & oldCap) == 0) {                                if (loTail == null)                                    loHead = e;                                else                                    loTail.next = e;                                loTail = e;                            }                            else {                                if (hiTail == null)                                    hiHead = e;                                else                                    hiTail.next = e;                                hiTail = e;                            }                        } while ((e = next) != null);                        if (loTail != null) {                            loTail.next = null;                            newTab[j] = loHead;                        }                        if (hiTail != null) {                            hiTail.next = null;                            newTab[j + oldCap] = hiHead;                        }                    }                }            }        }        return newTab;    }    

三、常用方法

        上面介绍了两个比较复杂的方法，接下来继续分析Map中比较常见的方法和内部的实现。

        1、get方法和containsKey方法    

        这两个方法是最常用的，都是根据给定的key值，一个获取对应的value，一个判断是否存在于Map中，在内部这两个方法都会调用一个finall方法，就是getNode，也就是查找对应key值的节点。

    public V get(Object key) {        Node<K,V> e;        return (e = getNode(hash(key), key)) == null ? null : e.value;    }        public boolean containsKey(Object key) {        return getNode(hash(key), key) != null;    }        /*     * 实现Map.get以及相关方法     */    final Node<K,V> getNode(int hash, Object key) {        Node<K,V>[] tab; //指向table数组        Node<K,V> first, e; //first为table[index]，即所在数组下标中第一个节点；e用于遍历节点        int n; K k;//n为table的长度，k用于指向节点的key                if ((tab = table) != null && (n = tab.length) > 0 &&//首先必须保证table数组不为空                    (first = tab[(n - 1) & hash]) != null) {//计算下标，保证数组下标中第一个节点不为null不然就肯定找不到直接返回null                    if (first.hash == hash && // 先检查第一个节点hash值是否相等                ((k = first.key) == key || (key != null && key.equals(k))))//再判断key，如果相等直接返回                return first;                        if ((e = first.next) != null) { //第一个不符合，就从下一个开始找                if (first instanceof TreeNode)//红黑树 O(logn)                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);                do {//不然就是链表O(n)                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                        return e;                } while ((e = e.next) != null);            }        }        return null;    }    

        可以看出getNode方法的大致过程：

1. table里的第一个节点，直接命中；
2. 如果有冲突，则遍历链表或二叉树去查找相同节点
3. 查找节点时先判断hash值是否相等
4. 如果hash值相等，再判断key值是否相等
5. 判断key值相等时，用==或equals或，整个判断条件为：(e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))

        2、putAll方法

        putAll方法用于将一个已有的Map加入现有的Map中，在内部也是调用一个final方法putMapEntries，这个方法也实现了最后一个构造函数。

    public void putAll(Map<? extends K, ? extends V> m) {        putMapEntries(m, true);    }            //用于实现Map.putAll和上面的那个构造函数    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {        int s = m.size();//s代表要加入的元素个数        if (s > 0) {                    if (table == null) { // 如果table为null，说明还没有进行初始化                            float ft = ((float)s / loadFactor) + 1.0F;//根据s计算容量和阈值                int t = ((ft < (float)MAXIMUM_CAPACITY) ?                         (int)ft : MAXIMUM_CAPACITY);                if (t > threshold)                    threshold = tableSizeFor(t);            }                        else if (s > threshold)//如果超出阈值，则进行扩容                resize();                        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {//逐个将节点加入                K key = e.getKey();                V value = e.getValue();                putVal(hash(key), key, value, false, evict);            }        }    }

        可以看出这大致过程就是先根据已有元素进行容量和阈值的计算，类似和初始化过程差不多，然后遍历Map，将其中元素逐个加入，加入的过程就是调用putVal，上面已经分析过。

        3、remove方法

        remove方法用于删除给定key值对应的节点并返回，如果不存在就返回null。在内部也是调用一个final方法 removeNode。

    public V remove(Object key) {        Node<K,V> e;        return (e = removeNode(hash(key), key, null, false, true)) == null ?            null : e.value;    }        /*     * 实现Map.remove及相关方法     */final Node<K, V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) {Node<K, V>[] tab;//指向table数组Node<K, V> p;//table[index]，链表第一个元素或红黑树根节点int n, index;//n为table数组的长度。index为hash值对应的下标if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) {Node<K, V> node = null, e;K k;V v;if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))node = p;else if ((e = p.next) != null) {if (p instanceof TreeNode)node = ((TreeNode<K, V>) p).getTreeNode(hash, key);else {do {if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {node = e;break;}p = e;} while ((e = e.next) != null);}}//上面的过程和getNode基本一样if (node != null && (!matchValue ||//如果找到了该节点 (v = node.value) == value || (value != null && value.equals(v)))) {if (node instanceof TreeNode)//如果是红黑树，在红黑树中删除节点((TreeNode<K, V>) node).removeTreeNode(this, tab, movable);else if (node == p)//如果是链表第一个节点tab[index] = node.next;//直接指向nextelse//p.next = node.next;//++modCount;--size;//afterNodeRemoval(node);return node;}}//节点不存在，返回nullreturn null;}

        可以看出，remove过程和get过程有很多相同的操作，都是先找到对应的元素，remove在查找之后会进行删除操作。

        4、size和isEmpty方法

        这两个方法很简单，一个返回元素个数，一个返回是否有元素。

    public int size() {        return size;    }        public boolean isEmpty() {        return size == 0;    } 

        5、clear方法

        清空整个Map。

    public void clear() {        Node<K,V>[] tab;        modCount++;        if ((tab = table) != null && size > 0) {            size = 0;            for (int i = 0; i < tab.length; ++i)                tab[i] = null;        }    }

        size置0，直接遍历table数组，全部置为null，节点不用管，交给垃圾回收。

        可以看出，clear方法后，Map的容量和阈值都是不变的，只是其中的元素被清空了。

        6、containsValue方法

        这个方法虽然看上去和containsKey差不多，而且作用也确实都是判断Map中是否含有某key或某value，但是内部的实现却是完全不一样的，containsKey会调用getNode方法进行查找，而containsKey是直接遍历所有元素逐个对比的。二者性能有着很大的差别。

    public boolean containsValue(Object value) {        Node<K,V>[] tab; V v;        if ((tab = table) != null && size > 0) {            for (int i = 0; i < tab.length; ++i) {                for (Node<K,V> e = tab[i]; e != null; e = e.next) {                    if ((v = e.value) == value ||                        (value != null && value.equals(v)))                        return true;                }            }        }        return false;    }

        可以看出，有两层循环，是挨个查找的，所以效率并不高。

        7、JDK1.8扩展方法

        jdk1.8貌似有了很多改进，比如红黑树好像就是1.8之后引进的，源码中专门列出了1.8中的新增方法。

    // Overrides of JDK8 Map extension methods    @Override    public V getOrDefault(Object key, V defaultValue) {        Node<K,V> e;        return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;    }    @Override    public V putIfAbsent(K key, V value) {        return putVal(hash(key), key, value, true, true);    }    @Override    public boolean remove(Object key, Object value) {        return removeNode(hash(key), key, value, true, true) != null;    }    @Override    public boolean replace(K key, V oldValue, V newValue) {        Node<K,V> e; V v;         if ((e = getNode(hash(key), key)) != null &&            ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {            e.value = newValue;            afterNodeAccess(e);            return true;        }        return false;    }    @Override    public V replace(K key, V value) {        Node<K,V> e;        if ((e = getNode(hash(key), key)) != null) {            V oldValue = e.value;            e.value = value;            afterNodeAccess(e);            return oldValue;        }        return null;    }    @Override    public V computeIfAbsent(K key,                             Function<? super K, ? extends V> mappingFunction) {        if (mappingFunction == null)            throw new NullPointerException();        int hash = hash(key);        Node<K,V>[] tab; Node<K,V> first; int n, i;        int binCount = 0;        TreeNode<K,V> t = null;        Node<K,V> old = null;        if (size > threshold || (tab = table) == null ||            (n = tab.length) == 0)            n = (tab = resize()).length;        if ((first = tab[i = (n - 1) & hash]) != null) {            if (first instanceof TreeNode)                old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);            else {                Node<K,V> e = first; K k;                do {                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k)))) {                        old = e;                        break;                    }                    ++binCount;                } while ((e = e.next) != null);            }            V oldValue;            if (old != null && (oldValue = old.value) != null) {                afterNodeAccess(old);                return oldValue;            }        }        V v = mappingFunction.apply(key);        if (v == null) {            return null;        } else if (old != null) {            old.value = v;            afterNodeAccess(old);            return v;        }        else if (t != null)            t.putTreeVal(this, tab, hash, key, v);        else {            tab[i] = newNode(hash, key, v, first);            if (binCount >= TREEIFY_THRESHOLD - 1)                treeifyBin(tab, hash);        }        ++modCount;        ++size;        afterNodeInsertion(true);        return v;    }    public V computeIfPresent(K key,                              BiFunction<? super K, ? super V, ? extends V> remappingFunction) {        if (remappingFunction == null)            throw new NullPointerException();        Node<K,V> e; V oldValue;        int hash = hash(key);        if ((e = getNode(hash, key)) != null &&            (oldValue = e.value) != null) {            V v = remappingFunction.apply(key, oldValue);            if (v != null) {                e.value = v;                afterNodeAccess(e);                return v;            }            else                removeNode(hash, key, null, false, true);        }        return null;    }    @Override    public V compute(K key,                     BiFunction<? super K, ? super V, ? extends V> remappingFunction) {        if (remappingFunction == null)            throw new NullPointerException();        int hash = hash(key);        Node<K,V>[] tab; Node<K,V> first; int n, i;        int binCount = 0;        TreeNode<K,V> t = null;        Node<K,V> old = null;        if (size > threshold || (tab = table) == null ||            (n = tab.length) == 0)            n = (tab = resize()).length;        if ((first = tab[i = (n - 1) & hash]) != null) {            if (first instanceof TreeNode)                old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);            else {                Node<K,V> e = first; K k;                do {                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k)))) {                        old = e;                        break;                    }                    ++binCount;                } while ((e = e.next) != null);            }        }        V oldValue = (old == null) ? null : old.value;        V v = remappingFunction.apply(key, oldValue);        if (old != null) {            if (v != null) {                old.value = v;                afterNodeAccess(old);            }            else                removeNode(hash, key, null, false, true);        }        else if (v != null) {            if (t != null)                t.putTreeVal(this, tab, hash, key, v);            else {                tab[i] = newNode(hash, key, v, first);                if (binCount >= TREEIFY_THRESHOLD - 1)                    treeifyBin(tab, hash);            }            ++modCount;            ++size;            afterNodeInsertion(true);        }        return v;    }    @Override    public V merge(K key, V value,                   BiFunction<? super V, ? super V, ? extends V> remappingFunction) {        if (value == null)            throw new NullPointerException();        if (remappingFunction == null)            throw new NullPointerException();        int hash = hash(key);        Node<K,V>[] tab; Node<K,V> first; int n, i;        int binCount = 0;        TreeNode<K,V> t = null;        Node<K,V> old = null;        if (size > threshold || (tab = table) == null ||            (n = tab.length) == 0)            n = (tab = resize()).length;        if ((first = tab[i = (n - 1) & hash]) != null) {            if (first instanceof TreeNode)                old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);            else {                Node<K,V> e = first; K k;                do {                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k)))) {                        old = e;                        break;                    }                    ++binCount;                } while ((e = e.next) != null);            }        }        if (old != null) {            V v;            if (old.value != null)                v = remappingFunction.apply(old.value, value);            else                v = value;            if (v != null) {                old.value = v;                afterNodeAccess(old);            }            else                removeNode(hash, key, null, false, true);            return v;        }        if (value != null) {            if (t != null)                t.putTreeVal(this, tab, hash, key, value);            else {                tab[i] = newNode(hash, key, value, first);                if (binCount >= TREEIFY_THRESHOLD - 1)                    treeifyBin(tab, hash);            }            ++modCount;            ++size;            afterNodeInsertion(true);        }        return value;    }    @Override    public void forEach(BiConsumer<? super K, ? super V> action) {        Node<K,V>[] tab;        if (action == null)            throw new NullPointerException();        if (size > 0 && (tab = table) != null) {            int mc = modCount;            for (int i = 0; i < tab.length; ++i) {                for (Node<K,V> e = tab[i]; e != null; e = e.next)                    action.accept(e.key, e.value);            }            if (modCount != mc)                throw new ConcurrentModificationException();        }    }    @Override    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {        Node<K,V>[] tab;        if (function == null)            throw new NullPointerException();        if (size > 0 && (tab = table) != null) {            int mc = modCount;            for (int i = 0; i < tab.length; ++i) {                for (Node<K,V> e = tab[i]; e != null; e = e.next) {                    e.value = function.apply(e.key, e.value);                }            }            if (modCount != mc)                throw new ConcurrentModificationException();        }    }

四、返回Set的相关方法

        HashMap类实现了Map接口，在Map中，定义了三个views相关的方法(源码注释里就是这么写的)。

    // Views    Set<K> keySet();    Collection<V> values();    Set<Map.Entry<K, V>> entrySet();

        顾名思义，这三个方法分别返回Map中的关键字集合，值集合和节点集合。在HashMap中实现了这三个方法。

        1、keySet方法
        返回包含Map中所有key值的Set，定义了一个继承自AbstractSet的内部类，它只会被new一次，因为在new之后会有一个全局变量keySet指向它，keySet变量是父类AbstractMap中定义的。

    public Set<K> keySet() {        Set<K> ks;//ks=keySet                return (ks = keySet) == null ? (keySet = new KeySet()) : ks;    }    final class KeySet extends AbstractSet<K> {        public final int size()                 { return size; }        public final void clear()               { HashMap.this.clear(); }        public final Iterator<K> iterator()     { return new KeyIterator(); }        public final boolean contains(Object o) { return containsKey(o); }        public final boolean remove(Object key) {            return removeNode(hash(key), key, null, false, true) != null;        }        public final Spliterator<K> spliterator() {            return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);        }        public final void forEach(Consumer<? super K> action) {            Node<K,V>[] tab;            if (action == null)                throw new NullPointerException();            if (size > 0 && (tab = table) != null) {                int mc = modCount;                for (int i = 0; i < tab.length; ++i) {                    for (Node<K,V> e = tab[i]; e != null; e = e.next)                        action.accept(e.key);                }                if (modCount != mc)                    throw new ConcurrentModificationException();            }        }    }

        可以看出，返回的keySet对象和Map是向关联的，而不是一个复制，对返回Set的操作也会对应到相应的Map节点中。下面是我测试的一个小例子。

public static void main(String[] args) {Map<Integer, String> map=new HashMap<Integer, String>();map.put(1, "1");map.put(2, "2");Set<Integer> keySet=map.keySet();System.out.println(keySet.contains(1));//truemap.remove(1);System.out.println(keySet.contains(1));//falsekeySet.remove(2);System.out.println(map.size());//0}

        2、values方法

        values方法与keySet基本类似，返回Map中包含的所有的value集合。很多操作的原理和上面都基本一样。

    public Collection<V> values() {        Collection<V> vs;        return (vs = values) == null ? (values = new Values()) : vs;    }    final class Values extends AbstractCollection<V> {        public final int size()                 { return size; }        public final void clear()               { HashMap.this.clear(); }        public final Iterator<V> iterator()     { return new ValueIterator(); }        public final boolean contains(Object o) { return containsValue(o); }        public final Spliterator<V> spliterator() {            return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);        }        public final void forEach(Consumer<? super V> action) {            Node<K,V>[] tab;            if (action == null)                throw new NullPointerException();            if (size > 0 && (tab = table) != null) {                int mc = modCount;                for (int i = 0; i < tab.length; ++i) {                    for (Node<K,V> e = tab[i]; e != null; e = e.next)                        action.accept(e.value);                }                if (modCount != mc)                    throw new ConcurrentModificationException();            }        }    }

        有几点不同之处：

· keySet返回的是Set，而values返回的是Collections，我觉得是因为Map中key是唯一的，Set也是不包含重复元素的。

· 返回的values中没有remove操作，因为Map可以对指定的key删除，却不可以对指定的value删除。

        3、entrySet方法

        该方法返回的也是set，不过它返回的直接是键值对，其他的和上面两个也差不多。

    public Set<Map.Entry<K,V>> entrySet() {        Set<Map.Entry<K,V>> es;        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;    }    final class EntrySet extends AbstractSet<Map.Entry<K,V>> {        public final int size()                 { return size; }        public final void clear()               { HashMap.this.clear(); }        public final Iterator<Map.Entry<K,V>> iterator() {            return new EntryIterator();        }        public final boolean contains(Object o) {            if (!(o instanceof Map.Entry))                return false;            Map.Entry<?,?> e = (Map.Entry<?,?>) o;            Object key = e.getKey();            Node<K,V> candidate = getNode(hash(key), key);            return candidate != null && candidate.equals(e);        }        public final boolean remove(Object o) {            if (o instanceof Map.Entry) {                Map.Entry<?,?> e = (Map.Entry<?,?>) o;                Object key = e.getKey();                Object value = e.getValue();                return removeNode(hash(key), key, value, true, true) != null;            }            return false;        }        public final Spliterator<Map.Entry<K,V>> spliterator() {            return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);        }        public final void forEach(Consumer<? super Map.Entry<K,V>> action) {            Node<K,V>[] tab;            if (action == null)                throw new NullPointerException();            if (size > 0 && (tab = table) != null) {                int mc = modCount;                for (int i = 0; i < tab.length; ++i) {                    for (Node<K,V> e = tab[i]; e != null; e = e.next)                        action.accept(e);                }                if (modCount != mc)                    throw new ConcurrentModificationException();            }        }    }

        有个区别就是entrySet是在HashMap中定义的，而不是继承自父类。在最上面第一部分代码中就列出了。

五、总结

        1、感觉HashMap的源码比前面两个List的都要复杂一些。

        2、这里只分析了一部分，关于链表红黑树转换的部分、迭代器、克隆、序列化等都没有贴出来。

        3、只是对HashMap有了基本的认识，以后有机会再深入的研究。

        4、这个编辑器真的好难用，我才发现原来大家都是用MarkDown编辑器的，准备学习一下。

        5、刚才去超市，在排队结账的时候发现我们和HashMap很相似啊，一个收银台代表table数组的一个，下面链表排了一堆人，当排队的人过多的时候，就会再增加几个结账窗口，相当于table数组resize了。这时候在原来排队的顾客就会有一部分到新开的窗口去排队，永远保证每个收银台的排队人数都是差不多的，哈哈哈哈。