HashMap第5讲——resize方法扩容源码分析及细节

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：希望对大家有所帮助，如果有纰漏或者更好的想法，请您一定不要吝啬你的赐教🙋。