put方法的源码和相关的细节已经介绍完了，下面我们进入扩容功能的讲解。
一、为什么需要扩容
这个也比较好理解。假设现在HashMap里的元素已经很多了，但是链化比较严重，即便树化了，查询效率也是O(logN)，肯定没有O(1)好，所以需要扩容来降低Hash冲突的概率，提高性能。
二、触发扩容的临界
我们知道，当++size>threshold条件成立时，就会调用resize()方法进行扩容。
ps：不明白的可以去看看第2讲——put方法源码。
三、扩容流程图
我们先看下扩容的流程图，更直观一点：
ps：图片看不清的可以把它下载到本地哦~
总结一下，扩容具体涉及以下三个部分：
如果某桶节点没有形成链表，则直接rehash到其它桶中。
如果桶中的链表已经形成红黑树，将原红黑树节点根据e.hash & oldCap==0条件将原红黑树分为两个红黑树，一部分放在原索引位置，另一部分放在原索引位置+原数组长度位置，且如果最后的结果节点个数小于等于6就转为链表。
如果桶中形成链表，则将链表重新连接：也是根据e.hash & oldCap==0条件将原链表分为两个链表，一部分放在原索引位置，另一部分放在原索引位置+原数组长度位置。
ps：更具体的可以看下面的源码注释
四、源码注释
看之前先看几个重要的参数：
//临界值，当实际大小（容量*负载因子）超过这个值，会进行扩容
int threshold;
//最大长度为2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//默认的负载因子为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//加载因子，默认为0.75
final float loadFactor;
//存储元素的数组，总是2^n
transient Node<K,V>[] table;源码注释：
final Node<K,V>[] resize() {
//原数组
Node<K,V>[] oldTab = table;
//原数组容量，为0说明是第一次初始化，反之扩容
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//临界值，当实际大小（容量*负载因子）超过这个值，会进行扩容
int oldThr = threshold;
//newCap：新数组长度 newThr：新扩容阈值（threshlod）
int newCap, newThr = 0;
if (oldCap > 0) {
//说明需要扩容
if (oldCap >= MAXIMUM_CAPACITY) {
//容量超过上限，无法再扩容，直接返回
threshold = Integer.MAX_VALUE;
return oldTab;
}
//新数组为原来的2倍 newCap = oldCap << 1
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//说明新数组长度小于Interger最大值，且原数组长度大于16
//扩容阈值修改为原来的两倍
newThr = oldThr << 1; // double threshold
}
//ps：下面的两个else说明是要初始化数组
else if (oldThr > 0) // initial capacity was placed in threshold
//说明new HashMap(length)时设置了长度
//那么新数组长度就是threshold（这个可以看我文章的第4讲）
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//这是没指定长度，新数组长度为16
newCap = DEFAULT_INITIAL_CAPACITY;
//扩容阈值为16*0.75=12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
//说明初始化时指定了长度，但小于16（此时需要计算阈值）
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将计算好的新阈值赋给threshold
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//初始化新Node数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//ps：这是要进行真正的扩容了
for (int j = 0; j < oldCap; ++j) {
//遍历老数组
Node<K,V> e;
if ((e = oldTab[j]) != null) {
//ps：当前位置有元素
//将当前位置置空
oldTab[j] = null;
if (e.next == null)
//只有一个元素，说明还没链化。
//将该元素进行rehash
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//ps：已经树化。这里就简单概括下
//把原tree一分为二，分别放到原数组位置和原数组长度+索引位置
//这两部分：如果元素数量小于等于6个就转为链表
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//ps：链化
//也是一份为二，lo：原索引位置，hi：索引位置+原数组长度位置
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//ps：根据e.hash & oldCap分类
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;
}五、为什么负载因子默认是0.75
我们知道当HashMap容量大于threshlod（阈值）时，会触发扩容操作，而threshlod=负载因子（loadFactory）*容量（capacity）。
loadFactory默认值为0.75（不会轻易修改），也就是当HashMap中元素个数达到容量的3/4时会进行自动扩容，那么为什么是负载因子为什么默认是0.75呢？
这里JDK官方文档中那个也给出了原因，大概意思是：
一般来说，默认负载因子（0.75）在时间和空间成本之间提供了很好的权衡。更高的值减少了空间开销，但增加了查找成本（在HashMap大多数操作中，包括get和put）。
我们可以逆向假设下：假设负载因子为1，也就是达到最大容量时再扩容，那么在HashMap中，最好的情况是这16个元素分别落在16个桶中，否则就必然会发生hash碰撞，而且元素越多，碰撞的几率就越大，查找速度也会越低，显然不合理。
所以负载因子不能太大，不然会导致大量的hash冲突，也不能太小，那样会浪费空间。
题外话：
Stack Overflor有一篇文章通过一个公式计算出负载因子值得最佳选择是在0.693，也就是0.7左右。
那为啥最终选择的是0.75呢？因为threshold=loadFactory*capacity，其中capacity永远是2^n，为了保证它俩乘积是个整数，因为0.75和任何2^n（n>1)乘积都是整数，所以才选择了0.75。
End：希望对大家有所帮助，如果有纰漏或者更好的想法，请您一定不要吝啬你的赐教🙋。
