上一篇文章中说到了HashMap在刚创建的时候第一次调用put方法的情况。下面我将梳理一下正常情况下put的情况，虽然都是公用一段代码，走的逻辑却大不相同。
看代码：

put( ): 非首次put

public V put(K key, V value) {
    //首先当然是计算key的hash值，具体可以参见我写的第一篇文章，
    //然后调用putVal
    return putVal(hash(key), key, value, false, true);
}

//onlyIfAbsent为false，说明如果已经存在相同(== 、equals)的key，则覆盖并返回旧值。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0）//此时table已经不为空
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            //没有产生hash碰撞，即table的第i个桶还没有元素，直接插入
            tab[i] = newNode(hash, key, value, null);  
        else {
            Node<K,V> e; K k;
            //此时第i个桶已经存在元素，且p是这个桶的第一个元素
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //先比较第一个元素，如果hash值相等并且 (是同一个key || 两个key equals)，直接跳到最后进行旧值覆盖
                e = p;
            else if (p instanceof TreeNode)
                //如果第i个桶是红黑树的话，执行红黑树的插入逻辑
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //如果第i个桶是一个链表，则遍历整个链表
                for (int binCount = 0; ; ++binCount) {  //利用binCount来计数链表的节点数
                    if ((e = p.next) == null) {
                        //已经遍历到链表最后，则在尾部添加一个节点
                        p.next = newNode(hash, key, value, null);
                        //假如此时链表有8个结点，遍历到第8个结点的时候（此时binCount为7，binCount初始值为0），在链表尾部新加了一个结点，
                        //此时链表有9个结点，而且binCount >= TREEIFY_THRESHOLD - 1 （7 >= 8-1）,条件成立，将链表转变为红黑树。
                        if (binCount >= TREEIFY_THRESHOLD - 1) 
                            treeifyBin(tab, hash);
                        break;
                    }
                    //遍历的过程中，如果与其中一个节点的key的hash值相等并且(同一个key || 两个key equals)，直接跳出循环到最后进行旧值覆盖
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { 
                V oldValue = e.value;
                //onlyIfAbsent为false，或者oldValue为null，进行旧值的覆盖
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);   //Do nothing！
                //直接返回旧值，后面的逻辑不会执行，因为结构没有发生变化，而且size也没有增加
                return oldValue;
            }
        }
        ++modCount;   //modCount为HashMap结构修改的次数，如新加入一个key-value（覆盖旧值不算，因为结构没有发生变化）、删除一个key-value、扩容等等。
        if (++size > threshold)
            //插入一个key-value之后，如果此时的size > threshold，进行扩容
            resize();
        afterNodeInsertion(evict);
        return null;
}

put(key, value)方法的主要流程如下：

1.计算key的hash值，定位到数组中的具体位置i。
2.查看i位置有没有元素，没有的话直接插入key-value。
3.如果i位置有元素，且满足相等条件，替换旧值。
3.如果i位置存了一个TreeNode，说明是一个红黑树，执行树的插入操作。
4.如果是一个链表，则遍历链表，过程中，如果有key满足相等条件，替换旧值；否则插入key-value到链表最后；插入之后如果当前链表长度大于TREEIFY_THRESHOLD，转换成红黑树结构。
5.size ++，如果size > threshold，进行扩容（具体扩容逻辑后面会讲）。

插入过程中，判断两个key是否相等的条件就是hash值相等，并且== 或者equals返回true.

resize( )：扩容

上面说到，如果插入一个key-value之后，size值大于阈值threshold，则进行扩容。那么具体是怎么扩容的？并且如何处理rehash问题？即如何将原来Map中的所有key-value重定位到新的数组中去？现在我们来看看具体是如何实现的。

先研究一下扩容之后如何求键值对在新数组中的索引：
我们知道HashMap在每次扩容的时候会扩容到之前的两倍。
假设扩容前容量为16 = 2^4，扩容后容量为32 = 2^5。而且我们已经知道用hash & (table.length - 1)可以求得key所在数组中的索引位置。
(至于容量为什么是2的幂次方，以及其他相关问题，可以参见我写的另一篇文章)

n-1=15      ==>   0000 0000  0000 0000  0000 0000  0000 1111  
&
key1(hash1) ==>   1010 1001  1100 1000  1000 1001  0010 0110    ===>       0000 0000  0000 0000  0000 0000  0000 0110       index为6
&
key2(hash2) ==>   1010 1001  1100 1000  1000 1001  0011 0110    ===>       0000 0000  0000 0000  0000 0000  0000 0110       index为6
-----------------------------------------------------------------------------------------------------------------------------------------

n-1=31      ==>   0000 0000  0000 0000  0000 0000  0001 1111                    
&
key1(hash1) ==>   1010 1001  1100 1000  1000 1001  0010 0110    ===>       0000 0000  0000 0000  0000 0000  0000 0110       index为6
&
key2(hash2) ==>   1010 1001  1100 1000  1000 1001  0011 0110    ===>       0000 0000  0000 0000  0000 0000  0001 0110       index为22（6 + 16）

（其中：hash1和hash2是hashCode( )计算的结果与高16位异或的结果）

看出什么道道了吗？

当容量扩大到2倍后，n-1的二进制表示就在高位多了1bit，原来是4个1，现在是5个1，这样，扩容后，当一个key的hash值的二进制形式在新增的那一位上为0，index值就不变，为1，index就是index + 原来的容量。

所以说，桶数组的容量为2的幂次方值，也有这个好处，在扩容的时候，只需要看key的hash值在新增的那个bit是0还是1，0的话，索引不变，1的话索引变为index + old capacity，

具体方法就是: (key.hash & oldCapacity == 0) ? index : index + oldCapacity，很基本的位操作。

这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。

搞清楚了如何进行rehash之后，下面来看一下代码是怎么处理的。

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {   //如果原来的capacity已经大于等于MAXIMUM_CAPACITY，则不进行扩容了，直接赋值Integer.MAX_VALUE给threshold
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)    //capacity扩容两倍，threshold也扩大两倍
                newThr = oldThr << 1; // double threshold
        }
        //接下来的两个else逻辑都不会执行
        else if (oldThr > 0) 
            newCap = oldThr;
        else {              
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {   //不会执行
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //开辟数组空间
        table = newTab;
        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 {             
                        //桶里存放的是链表
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        //这里引入两个链表：1、loHead  --> loTail
                        //               2、hiHead  --> hiTail
                        //第一个链表存放的是那些索引位置不变的键值对
                        //第二个链表存放的是那些索引位置变化的键值对
                        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 {          //索引值变为index + oldCap
                                //存放在第二个链表中
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {           //第j个桶存放第一个链表，索引值依然是j
                            loTail.next = null;  
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {           //第j+oldCap个桶存放第二个链表，索引值变成了j+oldCap
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

从代码中可以看出，链表中的节点在变更前后的相对位置没有改变。

总结

1、put操作可以覆盖原来的value，前提条件就是hash值相同且是同一个key，或者hash值相同且两个key equals。

2、插入链表后，元素大于8个，将链表转成红黑树

3、元素是放在链表的尾端

4、插入后，size += 1，如果size > threshold，执行扩容，

5、扩容时，对链表中的键值对重新计算桶索引，方法很巧妙。原来的链表会分裂为两个新链表，一个存放索引值不变的键值对，另一个存放索引值变化的键值对；并且键值对在新链表中的相对顺序没有变；但是在以前的JDK版本中，键值对的顺序变成了原来的倒序，它是依次将每个键值对插入到链表的头部。具体细节可以参考源码，这里就不详细展开了。

参考

1、https://www.cnblogs.com/xiarongjin/p/8310691.html
2、https://juejin.im/post/5aa5d8d26fb9a028d2079264
3、https://zhuanlan.zhihu.com/p/30360734