java集合之HashMap的扩容resize

JDK1.7中，resize时，index取得时，全部采用重新hash的方式进行了。JDK1.8对这个进行了改善。

以前要确定index的时候用的是(e.hash & oldCap-1)，是取模取余，而这里用到的是(e.hash & oldCap)，它有两种结果，一个是0，一个是oldCap，

比如oldCap=8,hash是3，11，19，27时，(e.hash & oldCap)的结果是0，8，0，8，这样3，19组成新的链表，index为3；而11，27组成新的链表，新分配的index为3+8；

JDK1.7中重写hash是(e.hash & newCap-1)，也就是3，11，19，27对16取余，也是3，11，3，11，和上面的结果一样，但是index为3的链表是19，3，index为3+8的链表是

27，11，也就是说1.7中经过resize后数据的顺序变成了倒叙，而1.8没有改变顺序。

原理：

我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。看下图可以明白这句话的意思，n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。

元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：

因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：

这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置。

resize（）：

        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) {        threshold = Integer.MAX_VALUE;        eturn oldTab;        }        // 没超过最大值，就扩充为原来的2倍        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);        }        // 计算新的resize上限        if (newThr == 0) {        float ft = (float)newCap * loadFactor;        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?        (int)ft : Integer.MAX_VALUE);        }        threshold = newThr;        @SuppressWarnings({"rawtypes"，"unchecked"})        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];        table = newTab;        if (oldTab != null) {        // 把每个bucket都移动到新的buckets中        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 { // 链表优化重hash的代码块        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;        }        // 原索引+oldCap        else {        if (hiTail == null)        hiHead = e;        else        hiTail.next = e;        hiTail = e;        }        } while ((e = next) != null);        // 原索引放到bucket里        if (loTail != null) {        loTail.next = null;        newTab[j] = loHead;        }        // 原索引+oldCap放到bucket里        if (hiTail != null) {        hiTail.next = null;        newTab[j + oldCap] = hiHead;        }        }        }        }        }        return newTab;        }

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {            TreeNode<K,V> b = this;            // Relink into lo and hi lists, preserving order            TreeNode<K,V> loHead = null, loTail = null;            TreeNode<K,V> hiHead = null, hiTail = null;            int lc = 0, hc = 0;            for (TreeNode<K,V> e = b, next; e != null; e = next) {                next = (TreeNode<K,V>)e.next;                e.next = null;                if ((e.hash & bit) == 0) {                    if ((e.prev = loTail) == null)                        loHead = e;                    else                        loTail.next = e;                    loTail = e;                    ++lc;                }                else {                    if ((e.prev = hiTail) == null)                        hiHead = e;                    else                        hiTail.next = e;                    hiTail = e;                    ++hc;                }            }            if (loHead != null) {                if (lc <= UNTREEIFY_THRESHOLD)                    tab[index] = loHead.untreeify(map);                else {                    tab[index] = loHead;                    if (hiHead != null) // (else is already treeified)                        loHead.treeify(tab);                }            }            if (hiHead != null) {                if (hc <= UNTREEIFY_THRESHOLD)                    tab[index + bit] = hiHead.untreeify(map);                else {                    tab[index + bit] = hiHead;                    if (loHead != null)                        hiHead.treeify(tab);                }            }        }