扩容原理
- 首先明确一下扩容以后所有node节点本质还是通过(n-1)&hash 得到索引，然后放入对应的node数组槽位中，但是jdk的开发者在这里使用了等价的计算方式加速了rehash的过程，将所有的node节点分成了需要移动和不需要移动两个链表，然后一次性移动到对应的位置上
- 要明白这个等价的计算方式是什么，需要一个直观的对比就可以很容易的理解，假设map当前容量是n=16(n-1 对应的二进制是0000 1111) ，node的hash值的二进制是1010 0101，那么在扩容前node 的索引的计算是通过如下方式得到
| 扩容前计算索引 | |
|---|---|
| 1010 0101 | |
| & | 0000 1111 |
| 0000 0101 | |
| 索引结果 | 5 |
扩容以后容量是n=32(对应的二进制是0001 1111),node本身的hash值是不变的，仍然是1010 0101，那么扩容后node 的索引的计算是通过如下方式得到
| 扩容后计算索引 | |
|---|---|
| 1010 0101 | |
| & | 0001 1111 |
| 0000 0101 | |
| 索引结果 | 5 |
发现计算后的索引结果和扩容前是一样的，那么是什么原因导致扩容前后的索引是一样的？或者是不一样的呢？我们把扩容前后的两次hash计算索引的过程放在一起对比一下
| 扩容前计算索引 | 扩容后计算索引 | ||
|---|---|---|---|
| （hash） | 1010 0101 | 101 0 0101 | |
| （n-1）& | 0000 1111 | & | 000 1 1111 |
| 0000 0101 | 0000 0101 | ||
| 索引结果 | 5 | 5 |
先给出结论，注意看一下(n-1) 的值他转化为二进制以后的第五位，也就是表中加粗的数字
- 它的左边高位都是0，做&运算以后无论hash值中对应的位是0或1，最后结果都是0，也就是不影响最后的计算结果
- 它的右边高位都是1，做&运算以后无论hash值中对应的位是0或1，最后结果都和原来的值保持一致，这是&的计算特性
- 结合上两条特点，那么无论扩容前后，低四位&以后的计算结果都是一样的都是5（0101），唯一影响计算结果的就是第5位，也就是说node的hash值的二进制如果第5位是0，那么扩容后索引不变，如果是1，扩容后的索引就变了，那么会变成什么呢？举个具体例子看一下
- 假设现在node的hash值是1011 0101，相比之前的node，现在例子中的hash值二进制第五位是1
| 扩容前计算索引 | 扩容后计算索引 | ||
|---|---|---|---|
| （hash） | 1011 0101 | 101 1 0101 | |
| &（n-1） | 0000 1111 | & | 000 1 1111 |
| 0001 0101 | 000 1 0101 | ||
| 索引结果 | 5 | 16 + 5 |
我们发现，最后扩容以后计算结果中第5位变成了1，低四位不变，也就是16 + 5，而这增加的16恰好是map扩容前的容量16，回到上面的问题，node的hash值的二进制如果第5位是1，扩容后的索引就是 扩容前的容量 + 原索引值。
- 那么为什么是第五位呢？因为扩容一倍以后，n-1的二进制位从4个1（1111）变为了5个1（11111），影响计算结果的恰恰是多出来的那一位1，那么现在可以再总结一下上面的规律，如何判断一个node在扩容后索引是否变化？如果多出来的那一位1和hash做位与运算结果中第五位是0，那么扩容后索引不变，如果是1那么扩容后的索引就是 扩容前的容量 + 原索引值
- 根据上面的结论，计算结果就可以简化为如下过程
| hash值二进制第五位是1 | hash值二进制第五位是0 | ||
|---|---|---|---|
| 1011 0101 | 101 0 0101 | ||
| & | 0001 0000 | & | 000 1 0000 |
| 0001 0000 | 000 0 0000 | ||
| 第五位结果 | 1 | 0 |
- 根据表格中计算过程可知，根据第五位的结果就能确定扩容后的索引
- 走到这里，就引出了最后一个问题，影响结果的第五位如何确定呢？我们发现进行计算的二进制数0001 0000 = 16 ，正好就是扩容前的容量值，所以最后的结论就是：
- hash & oldcap = 0 扩容后索引不变
- hash & oldcap ！=0 扩容后 索引= oldcap + 原索引值，这样回头再去看java中hashmap 扩容的原理源码就一目了然了
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//首次初始化后table为Null
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;//默认构造器的情况下为0
int newCap, newThr = 0;
if (oldCap > 0) {//table扩容过
//当前table容量大于最大值得时候返回当前table
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//table的容量乘以2，threshold的值也乘以2
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
//使用带有初始容量的构造器时，table容量为初始化得到的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) {
HashMap.Node<K,V> e;
if ((e = oldTab[j]) != null) {
// help gc
oldTab[j] = null;
if (e.next == null)
// 当前index没有发生hash冲突，直接对2取模，即移位运算hash &（2^n -1）
// 扩容都是按照2的幂次方扩容，因此newCap = 2^n
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof HashMap.TreeNode)
// 当前index对应的节点为红黑树，这里篇幅比较长且需要了解其数据结构跟算法，因此不进行详解，当树的个数小于等于UNTREEIFY_THRESHOLD则转成链表
((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 把当前index对应的链表分成两个链表，减少扩容的迁移量
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) {
// help gc
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
// help gc
hiTail.next = null;
// 扩容长度为当前index位置+旧的容量
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
参考
https://www.jianshu.com/p/321fdf485970
https://blog.csdn.net/u010890358/article/details/80496144#扩容机制核心方法Node%3CK%2CV%3E%5B%5D%20resize()