一.何时会发生resize()扩容
1.初始化HashMap的默认扩容一个 cap为16 ,threshold(阈值)为12的Node<K, V>[] newTab
2.HashMap中元素数量达到阈值,每次扩容的容量都是之前容量的2倍。。
二.resize()扩容的大致流程
第一步: 确定新数组的 容量 和 阈值(极限值/临界值)
第二步:将旧数组内容 复制到 新数组 当中(扩容的本质是 新数组替代旧数组)
注意:在对链表进行拆分的时候,会分为两个链表,因为数组扩容后长度是原来的二倍,元素在数组中下标的计算方式为:元素的hash值对数组的长度-1做与操作,数组长度发生变化,元素在数组中下标位置也可能发生变化
三.源码分析
final Node<K,V>[] resize() {
// 成员变量的table赋值给oldTab,就是将扩容前的table赋值给oldTab
Node<K,V>[] oldTab = table;
// 记录Map当前的容量
// 如果当前数组等于null长度返回0,否则返回当前数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//当前数组阈值
int oldThr = threshold;
// 声明两个变量,用来记录新的容量和阈值
int newCap, newThr = 0;
// 若当前容量不为0,表示存储数据的数组已经被初始化过
if (oldCap > 0) {
// 判断当前容量是否超过了允许的最大容量
if (oldCap >= MAXIMUM_CAPACITY) {
// 若超过最大容量,表示无法再进行扩容
// 则更新当前的阈值为int的最大值,并返回旧数组
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 将旧容量*2得到新容量,若新容量未超过最大容量值,并且旧容量大于默认初始容量(16),才则将旧阈值*2得到新阈值
// 在以前的扩容阀值的基础上翻倍,假如以前的数组长度16 扩容阀值为 16*0.75=12
// 扩容新的容量为之前的容量的2倍newCap = oldCap << 1 左移一位 原来的大小为 16 扩容以后位32 以此类推
// 新的扩容阀值也为原来的2倍 newThr = oldThr << 1; 左移动1位 原来的扩容阀值为12 现在的阀值为24 以此类推
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//将数组长度左移一位(翻倍) 新数组阈值变为之前的一倍
newThr = oldThr << 1; // double threshold
}
// 若不满足上面的oldCap > 0,表示数组还未初始化,
// 若当前阈值不为0,就将数组的新容量记录为当前的阈值;
// 为什么这里的oldThr在未初始化数组的时候就有值呢?
// 这是因为HashMap有两个带参构造器,可以指定初始容量,
// 若你调用了这两个可以指定初始容量的构造器,
// 这两个构造器就会将阈值记录为第一个大于等于你指定容量,且满足2^n的数(可以看看这两个构造器)
else if (oldThr > 0) // initial capacity was placed in threshold
//将老数组的阈值赋值给新数组
newCap = oldThr;
// 若上面的条件都不满足,表示你是调用默认构造器创建的HashMap,且还没有初始化table数组
else { // zero initial threshold signifies using defaults
// 则将新容量更新为默认初始容量(16)
// 阈值即为(容量*负载因子)12
// 初始化容量会走这个
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 经过上面的步骤后,newCap一定有值,但是若运行的是上面的第二个分支时,newThr还是0
// 所以若当前newThr还是0,则计算出它的值(容量*负载因子)
if (newThr == 0) {
// 再次扩容的阀值
float ft = (float)newCap * loadFactor;
// 获取新的阀值,小于最大容量就为上面计算的扩容阀值,否则为Integer.MAX_VALUE
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 将计算出的新阈值更新到成员变量threshold上
// 第一次添加的时候初始化threshold = newThr = 12
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 创建一个记录新数组用来存HashMap中的元素,容量为新的容量newCap
// 若数组不是第一次初始化,则这里就是创建了一个两倍大小的新数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 将新的的数组赋值给成员变量table
table = newTab;
// 判断旧数组是否等于空,不等于null开始将原来的数据加入到新数组中
if (oldTab != null) {
// 遍历原数组。把每个bucket都移动到新的bucket中,遍历旧的哈希表的每个桶,重新计算桶里元素的新位置
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 若原数组的j位置有节点存在,才进一步操作
if ((e = oldTab[j]) != null) {
// 清除旧数组对节点的引用,方便垃圾回收
oldTab[j] = null;
// 若table数组的j位置只有一个节点,则直接将这个节点放入新数组,位置可能在新的之前的位置也肯能在旧的容量加上旧的位置
// 使用 & 替代 % 计算出余数,即下标
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 { // preserve order
// 创建两个头尾节点,表示两条链表
// 因为旧链表上的元素放入新数组中,最多将变成两条链表
//loHead,loTail分别代表 **不需要移动** 的 **链头** 和 **链尾**
Node<K,V> loHead = null, loTail = null;
//hiHead ,hiTail 分别代表 **需要移动** 的 **链头** 和 **链尾**
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//循环确定原链表中每一个元素的去向,分两种情况:
//(1)要么是新索引 = 原索引 ;
//(2)要么是新索引 = 原索引 + 旧容量 ;
//因为newCap-1比oldCap-1只是多了一位1,然后通过和hash算法返回值与运算
//返回索引值,将当前元素存入对应的下标(对应的链表中)。
//再次与hash返回值与运算的时候,决定元素去留的只是最高位与运算的结果。
do {
// 记录当前节点的下一个节点
next = e.next;
// 注意:e.hash & oldCap这一步就是前面说的判断多出的这一位是否为1
// 若与原容量做与运算,结果为0,表示将这个节点放入到新数组中,下标不变
if ((e.hash & oldCap) == 0) {//jdk1.8 :尾插法
// 若这是不变链表的第一个节点,用loHead记录
if (loTail == null)//链尾为空==>首次插入,将链尾指向e
loHead = e;
// 否则,将它加入下标不变链表的尾部
else
//链尾有元素,链尾的next指向e,当有多个元素时候,while()完成链表的追加。
loTail.next = e;
// 更新尾部指针指向新加入的节点
loTail = e;
}
// 若与原容量做与运算,结果为1,表示将这个节点放入到新数组中,下标将改变
else {
// 若这是改变下标链表的第一个节点,用hiHead记录
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;
}
//将需要移动的链表拼接到新索引(旧索引+旧容量oldCap)位置
if (hiTail != null) {
hiTail.next = null;
// 这条链表放入的位置要在原来的基础上加上oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//将新数组返回
return newTab;
}
四.图解