final Node<K,V>[] resize() {
// 老的bucket 桶
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; // double threshold
}
// 用于带参数的初始化HashMap,因为你有参数,在构造函数就已经赋值了 初始化容器大小、加载因子、临界值
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]; // 初始化新的Node数组
table = newTab;
if (oldTab != null) {
// 遍历老数组
for (int j = 0; j < oldCap; ++j) {
// 这里的e特殊说明下,就是老数组 下标相同的链表元素
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 如果没有next,直接通过这个元素的hash和新数组长度减一 获取新的数组下标
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 如果是二叉树,需要把树分解
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
/**
* 如果有多个,就需要copy到新的表中
* 与1.7不同,1.7是每一个都rehash。
* 1.8 是根据根据一个链表,然后和老数组长度按位与。然后如果为0,到新数组还是原来的位置。如果不为0,位置就是之前的位置加老数组的长度作为新的下标。
* 说一下为什么用 (e.hash & oldCap) == 0 判断:
* 因为在1.7的时候,每个链表(hash值相同)都是重新根据新数组(原数组大小的2倍)进行取模的,比较麻烦。但其实1.8的做法和rehash结果一样,
* 但为什么1.8这样做呢?因为 数组的容量都是2的幂,数组容量减1得到的二进制位数要小于本来数组容量的位数(小1位 2^10 = 10000000000,2^10-1 = 1111111111 明显少1位)
* 前提 oldCap是2的幂,所以二进制肯定只有一个1,其他为0。那如果(e.hash & oldCap) == 0,e哈希值对应oldCap1的位置上的数肯定为0。
* 那数组变为2倍再减一,和之前的数组长度减一,就是最高位补了一个1(可以用15和31,31除以2 上15,余1 然后这个1就把之前最前面那个1顶上去了),
* 补的这个1和原数组最高位那个1在一个位置。前面也说到了,e.hash 对应的那个位置是0.所以扩容了,位置还是原来的位置。
*
*/
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;
}
对于1.8旧数组转新数组我画个图:
先记住 & 的前提是两个为1,才是1.有一个为0就是0.
图里面abcde代表e.hash,前面的就不需要管了,因为数组容量最高位1前面都是0,与完了肯定是0。
假如老数组大小(oldCap)是16,减一是15,看上面的图。位数是相差1位的(记住前面的高位都是0)。
那用e.hash和老数组长度按位与的时候,老数组因为是2的幂,所以只有最高位那1个1。如果
(e.hash & oldCap) == 0,那说明老数组里面的1对应e.hash位置肯定是0。
接着,数组的长度变为两倍,然后减一。就是之前数组减一的二进制前面补了一个1。补的这个1和之前数组最高位那个1是在一个位置(这是关键)。那我们知道e.hash 图中a位置是0,那么数组为2倍减一 补的那个1和0与还是0。所以数组位置不变。
我写的可能比较啰嗦,主要是为了我和大家理解。你可以按照这个思路来考虑:1.8为什么不像1.7那样重新哈希了,但1.8这样搞和重新哈希结果是一样的。那数组长度2倍减一和之前数组长度减一 就是在原来的基础上最高位多了一个1。那我们怎么知道e.hash 对应的那个位置是1还是0呢,是0反正原位置就不变了。那怎么判断呢?然后看人家用e.hash和原数组长度比,如果(e.hash & oldCap) == 0 得出原数组长度最高位那个1对应的e.hash那个位置是0.那为0就不变了吗?因为这个0的位置就是数组长度2倍减一和之前数组长度减一比较高位多的那个1的位置。