JDK源码-HashMap-resize扩容方法（JDK7和JDK8）

扩容操作可以认为是HashMap源码中最复杂的
resize方法的不是public的，不能通过client触发，所以只能直接进入源码查看

JDK 7

void resize(int newCapacity) {
	Entry[] oldTable = table;
	int oldCapacity = oldTable.length;
	if (oldCapacity == MAXIMUM_CAPACITY) {
		threshold = Integer.MAX_VALUE;
		return;
	}

	Entry[] newTable = new Entry[newCapacity];
	boolean oldAltHashing = useAltHashing;
	useAltHashing |= sun.misc.VM.isBooted() &&
			(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
	boolean rehash = oldAltHashing ^ useAltHashing;//判断是否需要对原node重新hash定位table的index
	transfer(newTable, rehash); //扩容核心方法
	table = newTable;
	threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

进入 transfer 方法

void transfer(Entry[] newTable, boolean rehash) {
	int newCapacity = newTable.length;
	for (Entry<K,V> e : table) {//直接遍历table变量
		//链表跟table[i]断裂遍历，头部往后遍历插入到newTable中
		while(null != e) {
			Entry<K,V> next = e.next;
			if (rehash) {
				e.hash = null == e.key ? 0 : hash(e.key);
			}
			int i = indexFor(e.hash, newCapacity);
			e.next = newTable[i];
			newTable[i] = e;
			e = next;
		}
	}
}

扩容过程总结：
创建一个新的数组newTable，容量是oldTable的一倍
遍历oldTable，拿到每个链表
遍历链表，头插法插入newTable

---

JDK 8

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;
			return oldTab;
		}
		else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && //容量翻倍
				 oldCap >= DEFAULT_INITIAL_CAPACITY)
			newThr = oldThr << 1; //扩容阈值也翻倍
	}
	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);
	}
	threshold = newThr;
	@SuppressWarnings({"rawtypes","unchecked"})
		Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
	table = newTab;
	if (oldTab != null) {
		for (int j = 0; j < oldCap; ++j) {//开始遍历oldTable
			Node<K,V> e;
			if ((e = oldTab[j]) != null) {
				oldTab[j] = null;
				if (e.next == null) //table[i]没值
					newTab[e.hash & (newCap - 1)] = e;
				else if (e instanceof TreeNode) //table[i]是红黑树的结构
					((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
				else { //table[i]是链表的结构，扩容后还是保持顺序的
					Node<K,V> loHead = null, loTail = null; //“低链表”的头和尾，即扩容后的在new table的index和old index是一样的
					Node<K,V> hiHead = null, hiTail = null; //“高链表”的头和尾，即扩容后的在new table的index是old index的2倍
					Node<K,V> next;
					do {
						next = e.next;
						if ((e.hash & oldCap) == 0) {//newTable index ==  oldTable index
							if (loTail == null)
								loHead = e;//头只当初始时才赋值
							else
								loTail.next = e;//新插入的都到添加到tail中
							loTail = e;
						}
						else {//newTable index ==  oldTable index * 2
							if (hiTail == null)
								hiHead = e;//头只当初始时才赋值
							else
								hiTail.next = e;//新插入的都到添加到tail中
							hiTail = e;
						}
					} while ((e = next) != null);
					if (loTail != null) { //将“低链表”添加到newTable中
						loTail.next = null;
						newTab[j] = loHead;
					}
					if (hiTail != null) {//将“高链表”添加到newTable中
						hiTail.next = null;
						newTab[j + oldCap] = hiHead;
					}
				}
			}
		}
	}
	return newTab;
}

总结（先针对链表操作的总结，红黑树的后续文章会写）：
如果是链表处理（红黑树的后续文章讨论），那么就将oldTable[i]分成高低链表，生成后插入到newTable中

---

对比

JDK7是每拿到一个Node就直接插入到newTable，而JDK8是先插入到高低链表中，然后再一次性插入到newTable。
所以链表的扩容过程JDK7会出现死循环问题，而JDK8避免了这个问题。
JDK8跟原先的链表对比Node之间顺序是一致的，而JDK7是是反过来的。