前言
上一篇讲了put方法,在put方法的最后,我们需要检查容量是否超过阈值,,如果越界需要进行扩容。resize方法就是对hashmap进行扩容。那么hashmap的扩容需要哪些步骤呢?
假如我是设计的作者,我会先创建一个更大容量的数组,然后遍历原table,重新计算所有的节点的hash值对应的下标,然后将节点转移到新table中。那么这其中存在这几个问题:
- 什么时候进行resize操作?
- 扩容后的新数组容量为多大比较合适?
- 节点在转移的过程中是一个个节点复制还是一串一串的转移?
可以说这些问题设计者都解决的非常好~接下来看一下源码:
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不为空
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
}
/**
* 从构造方法我们可以知道
* 如果没有指定initialCapacity, 则不会给threshold赋值, 该值被初始化为0
* 如果指定了initialCapacity, 该值被初始化成大于initialCapacity的最小的2的次幂
* 这里这种情况指的是原table为空,并且在初始化的时候指定了容量,
* 则用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);
}
// 计算指定了initialCapacity情况下的新的 threshold
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
/**从以上操作我们知道, 初始化HashMap时,
* 如果构造函数没有指定initialCapacity, 则table大小为16
* 如果构造函数指定了initialCapacity, 则table大小为threshold,
* 即大于指定initialCapacity的最小的2的整数次幂
* 从下面开始, 初始化table或者扩容, 实际上都是通过新建一个table来完成
*/
@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) {
/** 这里注意, table中存放的只是Node的引用,这里将oldTab[j]=null只是清除旧表的引用,
* 但是真正的node节点还在, 只是现在由e指向它
*/
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;
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;
}
resize最重要的操作之一就是对链表的拆分了,那么resize是如何拆分链表的呢?再来看一下代码:
HashMap.Node<K,V> loHead = null, loTail = null;
HashMap.Node<K,V> hiHead = null, hiTail = null;
HashMap.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;
}
这里定义了4个变量:loHead, loTail ,hiHead , hiTail,这四个变量从字面意思可以看出应该是两个头节点,两个尾节点。那么为什么需要两个链表的头尾节点呢?看一张图就明白了:
这张图中index=2的桶中有四个节点,在未扩容之前,它们的 hash& cap 都等于2。在扩容之后,它们之中2、18还在一起,10、26却换了一个桶。这就是这句代码的含义:选择出扩容后在同一个桶中的节点。
if ((e.hash & oldCap) == 0)
我们这时候的oldCap = 8,2的二进制为:0010,8的二进制为:1000,0010 & 1000 =0000
10的二进制为:1010,1010 & 1000 = 1000,
18的二进制为:10010, 10010 & 1000 = 0000,
26的二进制为:11010,11010 & 1000 = 1000,
从与操作后的结果可以看出来,2和18应该在同一个桶中,10和26应该在同一个桶中。
所以lo和hi这两个链表的作用就是保存原链表拆分成的两个链表。
if ((e.hash & oldCap) == 0) {
//尾节点为空,说明lo链表是空的
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
现在再来看这段代码是不是好理解多了?找到拆分后仍处于同一个桶的节点,将这些节点重新连接起来。
下面这段代码是将拆分完的链表放进桶里的操作,比较简单,只需要将头节点放进桶里就ok了,newTab[j]和newTab[j + oldCap]分别代表了扩容之后原位置与新位置,就相当于之前那张图中的2和10.
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
总结
最后我们再来总结一下之前提到的3个问题,
-
什么时候进行resize操作?
有两种情况会进行resize:1、初始化table;2、在size超过threshold之后进行扩容
-
扩容后的新数组容量为多大比较合适?
扩容后的数组应该为原数组的两倍,并且这里的数组大小必须是2的幂
-
节点在转移的过程中是一个个节点复制还是一串一串的转移?
从源码中我们可以看出,扩容时是先找到拆分后处于同一个桶的节点,将这些节点连接好,然后把头节点存入桶中即可
传送门
深入理解HashMap(一)hashmap所用算法、构造函数
深入理解HashMap(二)put方法解析
深入理解HashMap(三)resize方法解析
深入理解HashMap(四)get方法解析
深入理解HashMap(五)remove方法解析