各位读者大家好呀！今天小卡给大家带来的是HashMap resize()方法的源码解读~
HashMap 的 resize() 方法主要用于在散列表超过阈值时进行扩容，以避免过高的哈希冲突，从而保证哈希表的查找和插入性能。下面是 resize() 方法的主要步骤和核心逻辑：
- 判断是否需要扩容：
HashMap的扩容发生在size超过threshold时，threshold是HashMap扩容的触发阈值，通常等于当前容量与负载因子的乘积（默认负载因子为 0.75）。当size超过这个阈值，resize()就会被触发。 - 计算新容量：扩容时，
HashMap的容量通常会变为当前容量的两倍。例如，默认初始容量为 16，扩容后将变为 32。如果新容量超出了HashMap的最大容量限制（MAXIMUM_CAPACITY），则会设定为最大容量。 - 重新计算阈值：新容量会对应新的阈值，新阈值等于新容量乘以负载因子。这样确保在新的容量下，
HashMap依然能保持合理的负载率。 - 重新分配桶位置：扩容后，需要将原来
HashMap中的每个桶（链表或红黑树）重新映射到新的桶中，因为容量发生变化后，键的哈希值与新容量的取模结果可能会不同。具体过程如下：
-
- 遍历旧表中的所有元素。
- 重新计算每个元素的哈希位置，将其放入新的桶中。
- 避免数据丢失和保持顺序：为了防止数据丢失，
resize()方法会将旧表的数据一个一个地迁移到新表。
那么我们下面就进入今天的源码解读吧~
//整个resize方法其实就干了两件事情初始table再扩容
final Node<K,V>[] resize() {
//获取老表
Node<K,V>[] oldTab = table;
//老表容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//老表阈值
int oldThr = threshold;
//新表容量以及阈值
int newCap, newThr = 0;
//这里首先是判断是需要扩容还是初始化table,如果需要的是扩容，就会这里根据老表的容量以及阈值计算出新表的容量及阈值（double）。
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
}
//这个判断表示需要初始化table但是，创造容器时指定了初始容量和负载因子。
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) {
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 { // preserve order
//这里定义了两个头尾指针，看似是想把原本桶中的链表分成两链。
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//Q1:我们猜测这个循环就是要将旧表桶中的链表分成两个新的链表，那么为什么要这么做呢？为什么不直接把链表中的每个元素都重hash定位到新表呢。
do {
next = e.next;
//对应位为0的键值对，在新表中的索引下标就等于老表中的索引下标。
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//对应位为1的键值对，在新表中的索引下标就等于老表中的索引下标+oldCap。
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//将lotail和lohead指向的链表移到新表中与旧表中原链表所在相同的索引下标的位置。
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//将hitail和hihead指向的链表移到新表中与旧表中原链表所在索引下标+oldCap的位置。
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//返回新表。
return newTab;
}
Q1:我们猜测这个循环就是要将旧表桶中的链表分成两个新的链表，那么为什么要这么做呢？为什么不直接把链表中的每个元素都重hash定位到新表呢。
do {
next = e.next;
//对应位为0的键值对，在新表中的索引下标就等于老表中的索引下标。
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//对应位为1的键值对，在新表中的索引下标就等于老表中的索引下标+oldCap。
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
思考这个问题之前我们首先来回顾一下hashMap中一个键值对是怎么定位到table中的索引下标的，其实通常的做法是直接取余比:
index = hash % capicity ;
但是好像HashMap的开发者们用的是位运算：
index = hash & (capicity-1);
而java的开发者之所以放着，对小白更友好，更易懂的取余不用，而去用&运算，根本原因就是因为位运算比取余运算要快很多。
好的我们现在回到这个问题上来，之所以在数据迁移的时候把一个桶中的链表，分成两个链表然后直接将链表头迁移到新表中计算出来的位置，其实无非就是减少重新计算索引下标的次数，和元素迁移的次数，从而达到提高扩容速度的效果。
那么为什么能够这么做呢？我们，可以先观察下面几张图片：
不难发现扩容两背后，capicity-1的二进制吗会增加一个最高有效位，那么在老表中同一个桶中的链表上的节点，就会因为他们hash值的二进制码与capicity的二进制码新增的那个最高有效位对应的位置上是0还是1，来决定他们在新表中的下标索引与老表是否相同还是老表索引+oldCap。而通过让hash值与oldCap进行与运算就能够的到判断。
好的本期内容就讲到这里，如果读者们在阅读中有什么不同地意见欢迎到评论区进行指正哈~
