java hashmap1.8扩容源码分析

扩容机制

阅读本文需要知道hashmap的数据结构。
我们先梳理一下扩容时应该有的操作：

1. 计算新的cap和thr
2. 创建新的tab
3. 将原tab的元素放入新tab中

简单总结:扩容时需要计算新tab的容量和临界点，并且通过遍历tab的方式将每个entry放到新的tab中，在这个过程中，红黑树可能转换为链表。

1.计算容量和临界点

主要逻辑在下面：

        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
        //当老容量已经大于最大容量时，临界点设置为Integer的最大值
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //如果老容量扩大两倍小于最大值并且老容量大于默认容量16时，新容量为老容量扩大两倍，临界点同样扩大两倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //下面是初始化的阶段，初始化在有老临界点时，用临界点当容量，如果没有就用默认的容量和临界点
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            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);
        }

2.将老entry移动到新tab

我们思考一个问题，oldtab中有10个entry，我们怎么分配这10个entry在新tab中的下标呢？分配过程中我们还得保证这些entry放入的下标也是满足新的put运算的。

先回顾一下put计算下标的方法:

假设oldcap = 10000(二进制)=16,newcap = 32 = 100000
有两个元素hashcode分别为111111，101111。
那么index=(oldcap-1)&hash，也就是

111111&1111 = 15

101111&1111 = 15

所以，以上两个都在同一个下标tab[15]。

而在resize中，计算方法flag = hash&oldcap，也就是hash&10000。

111111&10000=10000

101111&10000=0

可以发现通过这个运算，我们把原来hash冲突的entry分开了。
我们知道同一个index中的entry的hashcode在原put运算时，结果必然一致。同理cap转为2进制为n位，那么hashcode在n-1位上的特征值都是一样的，但是第n位不一样，刚好resize中就利用了第n位的特征值，用来区分是在原index还是在原index+oldcap。

所以

111111在15+oldcap=31的下标

101111在15的原index

那么思考一下，这个下标计算方式，满足新的tab的put计算方式吗，是的。

我们知道put是&cap-1的计算方法，并且cap一定是2的n次幂，所以不管怎么扩容，无非就是&时多加几位1罢了。

新的put计算：

111111&11111= 31

101111&11111= 15

这样就把原链表分成了两个链表放在了不同的index上,并且满足了新put的运算。

上述的计算方式依然有缺陷，在极端场景下，假设hashcode在第n位的特征值都一样，那么就算扩容后，这些元素依然在同一个槽中，并没有起到优化查询的效果，所以如果使用自定义对象当key，需要着重考虑hashcode的计算方式。

以下是源码：

      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 { // 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;

ps：现在找工作越来越卷了，一些代码不仅要知道原理，还要深入源码，面试官甚至要求你仿照写个伪代码。