Java1.8 对HashMap的resize()的理解

final Node[] resize() {
	Node[] oldTab = table;
	int oldCap = (oldTab == null) ? 0 : oldTab.length;
	int oldThr = threshold;
	int newCap, newThr = 0;
	// 只有非第一次扩容才会进来（第一次扩容在第一次put）
	if (oldCap > 0) {
		// oldCap最大为MAXIMUM_CAPACITY(2^30),可查看带参构造方法①
		if (oldCap >= MAXIMUM_CAPACITY) {
			 /**
                 * threshold变成MAX_VALUE(2^31-1),随它们碰撞。但是oldCap不改变,
                 * 因为如果oldCap翻倍就为负数了,如果赋值为MAX_VALUE,
                 * 参考 Map容量为什么不能为MAX_VALUE②
                 */
			threshold = Integer.MAX_VALUE;
			return oldTab;
		}
		// 容量翻倍
		else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
				 oldCap >= DEFAULT_INITIAL_CAPACITY)
			/**
             * 为什么需要判断oldCap >= DEFAULT_INITIAL_CAPACITY呢？
             * 应该是容量较小时 capacity * loadFactor造成的误差比较大,
             * 例如初始化容量为2 threshold则为1,如果每次扩容threshold都翻倍,
             * 那负载因子是0.5了。
             * 为什么只小于16呢？
             * 我猜测是在每次扩容都计算threshold和用位运算翻倍之间做权衡
             */
			newThr = oldThr << 1; 
	}
	// 带参初始化会进入这里,主要是为了重新算threshold
	else if (oldThr > 0) 
		newCap = oldThr;
	// 不带参初始化会进入这里
	else {               
		newCap = DEFAULT_INITIAL_CAPACITY;
		newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
	}
	// 重新算threshold
	if (newThr == 0) {
		float ft = (float)newCap * loadFactor;
		newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
				  (int)ft : Integer.MAX_VALUE);
	}
	threshold = newThr;
	// 扩容
	Node[] newTab = (Node[])new Node[newCap];
	table = newTab;
	// 复制数据到新table中
	if (oldTab != null) {
		// 遍历Node
		for (int j = 0; j < oldCap; ++j) {
			Node 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)e).split(this, newTab, j, oldCap);
				else { 
					// 之所以定义两个头两个尾对象,是由于链表中的元素的下标在扩容后,要么是原下标+oldCap,要么不变,下面会证实
					Node loHead = null, loTail = null;
					Node hiHead = null, hiTail = null;
					Node 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) {
						// 尾部节点next设置为null，代码严谨
						loTail.next = null;
						newTab[j] = loHead;
					}
					// 新下标对应的链表
					if (hiTail != null) {
						hiTail.next = null;
						newTab[j + oldCap] = hiHead;
					}
				}
			}
		}
	}
	return newTab;
}

①带参构造方法
public HashMap(int initialCapacity, float loadFactor) {
	if (initialCapacity < 0)
		throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
	// 容量最大为MAXIMUM_CAPACITY(2^30)
	if (initialCapacity > MAXIMUM_CAPACITY)
		initialCapacity = MAXIMUM_CAPACITY;
	if (loadFactor <= 0 || Float.isNaN(loadFactor))
		throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
	this.loadFactor = loadFactor;
	// threshold初始化为最接近initialCapacity的2的幂次方，并且大于或等于initialCapacity。但是在第一次put的时候，threshold会变成threshold * loadFactor
	this.threshold = tableSizeFor(initialCapacity);
}

②Map容量为什么不能为MAX_VALUE
该为题可转为：为什么在Java1.8,每次扩容都为2的幂次方呢？
// 计算下标,下面是map的put和get中都用到计算下标的
(n - 1) & hash

当容量为MAX_VALUE(2^31-1)时,转换成二进制
	hash
&
	0111 1111 1111 1111 1111 1111 1111 1110
-----------------------------------------------
        xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx0
从上面可看出最低位无论hash是任何值时,都为0,也就是下标只有2^30种可能,有2^30-1个下标没有被使用
所以当容量为MAX_VALUE(2^31-1)时会造成一半的空间浪费,效率等同于MAXIMUM_CAPACITY(2^30)

③e.hash & oldCap
该步骤是为了计算位置是否需要移动
因为oldTab的元素下标是根据 hash(key) & (oldCap-1) 计算的,如果扩容后,计算下标是 hash(key) & (2*oldCap-1)
换成二进制就比较清晰了

 

所以，HashMap扩容的时候，不需要像Java1.7那样重新算hash值，只要看e.hash对应2*oldCap-1高位那个
bit是1还是0就好了，是0下标没变，是1索引变成：原下标+oldCap,这也是Java1.8优化的地方之一。

参考：Java 8系列之重新认识HashMap