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);
                }
            }
        }