前言
点赞在看，养成习惯。
点赞收藏，人生辉煌。
点击关注【微信搜索公众号：编程背锅侠】，防止迷路。
HashMap系列文章
第一篇 HashMap源码中的成员变量你还不懂? 来来来！！！整理好的成员变量源码解析
第二篇 撸啊撸，再次撸HashMap源码，踩坑源码中构造方法！！！每次都有收获
第三篇 MoxiMoxi ！！！你看过HashMap中的put方法的源码吗？
第四篇 HashMap源码中的resize扩容方法除了扩容还有一个用途你真的知道吗？
final HashMap.Node<K,V>[] resize()扩容源码
源码解析
final Node<K,V>[] resize() {
// 成员变量的table赋值给oldTab，就是将扩容前的table赋值给oldTab
// 第一次添加元素的时候oldTab = table=null，再次添加的时候oldTab = table为添加之前的table数组
Node<K,V>[] oldTab = table;
// 记录Map当前的容量
// 如果当前数组等于null长度返回0，否则返回当前数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 记录Map允许存储的元素数量，即阈值（容量*负载因子），超过这个阀值要扩容
// 首次添加元素的时候初始化容量这个oldThr=threshold=0，再次添加元素的时候会将当前的扩容阀值赋值给oldThr
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)
// 将旧阈值*2得到新阈值
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
// 创建两个头尾节点，表示两条链表
// 因为旧链表上的元素放入新数组中，最多将变成两条链表
// 一条下标不变的链表，一条下标+oldCap
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
// 循环遍历原链表上的每一个节点
do {
// 记录当前节点的下一个节点
next = e.next;
// 注意：e.hash & oldCap这一步就是前面说的判断多出的这一位是否为1
// 若与原容量做与运算，结果为0，表示将这个节点放入到新数组中，下标不变
if ((e.hash & oldCap) == 0) {
// 若这是不变链表的第一个节点，用loHead记录
if (loTail == null)
loHead = e;
// 否则，将它加入下标不变链表的尾部
else
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;
}
// 另一条链表与上同理
if (hiTail != null) {
hiTail.next = null;
// 这条链表放入的位置要在原来的基础上加上oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
概括总结
这个resize扩容方法有两个作用。
- 首次添加元素的时候，执行的resize方法是初始化数组。
- 再次添加的元素，如果容量达到了扩容的阀值，需要进行扩容，执行的是扩容。
面试总结
HashMap什么时候才需要扩容？
当HashMap中的元素个数超过数组⼤小(数组⻓度)*loadFactor(负载因子)时，就会进行数组扩容， loadFactor的默认值(DEFAULT_LOAD_FACTOR)是0.75,这是⼀个折中的取值。也就是说，默认情况下， 数组⼤⼩为16，那么当HashMap中的元素个数超过16×0.75=12(这个值就是阈值或者边界值threshold 值)的时候，就把数组的⼤小扩展为2×16=32，即扩⼤一倍，然后重新计算每个元素在数组中的位置，⽽这是一个⾮常耗性能的操作，所以如果我们已经预知HashMap中元素的个数，我们可以创建一个预知大小的集合，那么预知元素的个数能够有效的提高HashMap的性能。
当HashMap中的其中一个链表的对象个数如果达到了8个，此时如果数组长度没有达到64，那么 HashMap会先扩容解决，如果已经达到了了64，那么这个链表会变成红黑树，节点类型由Node变成 TreeNode类型。当然，如果映射关系被移除后，下次执行resize⽅法时判断树的节点个数低于6，也会再把树转换为链表。
进⾏扩容，会伴随着一次重新hash分配，存放位置变化了吗？
进行扩容，会伴随着一次重新hash分配，并且会遍历hash表中所有的元素，是⾮常耗时的。在编写程序中，要尽量避免resize。
HashMap在进行扩容时，使⽤的rehash⽅式非常巧妙，因为每次扩容都是翻倍，与原来计算的 (n- 1)&hash的结果相比，只是多了一个bit位，所以节点要么就在原来的位置，要么就被分配到"原位置**+**旧容量"这个位置。
位置变换详解
&与运算和^异或运算
&与运算
运算规则:相同的二进制数位上，都是1的时候，结果为1，否则为零。
案例：5 & 11 = 1
5 0101
& 11 1011
………………………………
结果： 0001【运算结果：1】
^异或运算
运算规则:相同的二进制数位上，数字相同，结果为0，不同为1。
案例：5 ^ 11 = 14
5 0101
^ 11 1011
………………………………
结果： 1110【运算结果：14】
(h = key.hashCode()) ^ (h >>> 16)演示
h = key.hashCode(): 1111 1111 1111 1111 1111 1010 1100 1010 这个值代表哈希code值
………………………………………………………………………………………………………………………………………………………………………………………………………………………………
h : 1111 1111 1111 1111 1111 1010 1100 1010
h >>>16 : 0000 0000 0000 0000 1111 1111 1111 1111
h ^ (h >>> 16): 1111 1111 1111 1111 0000 0101 0011 0101
………………………………………………………………………………………………………………………………………………………………………………………………………………………………
(n - 1)&hash计算的是在集合中的插入桶的位置
n - 1: 0000 0000 0000 0000 0000 0000 0000 1111【假设的容量为16-1=15】
hash: 1111 1111 1111 1111 0000 0101 0011 0101【这个是上面高16位和低16位异或得到的】
&与运算的结果: 0000 0000 0000 0000 0000 0000 0000 0101 =>[5]
………………………………………………………………………………………………………………………………………………………………………………………………………………………………
【重点】假如现在扩容，这个容量变为了32，那么上面计算的索引为5，到扩容后的集合的位置可能是5或者是21
(n - 1)&hash计算的是在集合中的插入桶的位置
n - 1: 0000 0000 0000 0000 0000 0000 0001 1111【假设的容量为32-1=31】
hash: 1111 1111 1111 1111 0000 0101 0011 0101【这个是上面高16位和低16位异或得到的】
&与运算的结果: 0000 0000 0000 0000 0000 0000 0001 0101 =>[21]
假如hash位置为0 : 0 =>[5]
………………………………………………………………………………………………………………………………………………………………………………………………………………………………
扩容以后，上面计算得到的便是可能在原来的位置5上，也可能在在新的位置21上。
谢谢点赞
- 创作不易， 非常欢迎大家的点赞、评论和关注(^_−)☆
- 你的点赞、评论以及关注是对我最大的支持和鼓励，而你的支持和鼓励
- 我继续创作高质量博客的动力 ！！！