高薪程序员&面试题精讲系列43之HashMap扩容机制的底层实现原理，HashMap扩容后是如何进行rehash操作的？

Posted 2022-01-11 一一哥Sun

一. 面试题及剖析

1. 今日面试题

请说一下HashMap及其底层实现原理

HashMap中是如何计算key的hash值的？

HashMap是如何进行扩容的？

说说HashMap的扩容机制原理

HashMap扩容后是如何重新进行hash计算的？

......

2. 题目剖析

在前4篇文章中，壹哥 给大家介绍了HashMap的基本特点、底层数据结构、HashMap中的重要属性，分析了HashMap的默认初始容量、负载因子，还有HashMap是如何保证其容量必须是2的N次方的，以及HashMap的put()方法执行流程。但在HashMap中，其底层内容非常的复杂，所以接下来在今天的文章中，壹哥 会继续给大家剖析HashMap的底层源码，敬请关注哦。

前4篇文章地址如下：

高薪程序员&面试题精讲系列39之说说HashMap的特点及其底层数据结构

高薪程序员&面试题精讲系列40之HashMap默认初始容量、最大容量、负载因子是多少？链表转红黑树阈值是多少？HashMap什么时候进行扩容？

高薪程序员&面试题精讲系列41之HashMap的容量为什么必须是2的N次方？说说HashMap添加数据的流程吧

高薪程序员&面试题精讲系列42之HashMap中如果出现冲突怎么解决？如何计算key的hash值、如何进行数组索引定位？
 

二. HashMap的扩容机制(重点)

本节相关面试题:

HashMap的扩容机制是怎么样的？

在HashMap的众多面试题中，有一个题目始终无法被绕过去，那就是HashMap的扩容机制。

1. 扩容机制简介

所谓的扩容(resize)机制，就是重新计算扩大数组的容量。我们一直向HashMap数组中添加新元素，当HashMap内部的数组无法装载更多的元素时，HashMap就需要扩大数组原先的容量了，以便能装入更多的元素。HashMap会遵循2倍扩容的原则，每次扩容之后数组的大小都是扩容前的2倍。

2. 扩容触发时机

那HashMap什么时候会进行扩容呢？壹哥 在这里给大家总结一下JDK 8中的HashMap，会在什么时候触发resize()扩容方法，有以下几种情况会触发扩容机制:

①. 当HashMap中使用的位桶数量，达到 总容量*负载因子 的时候会触发扩容；

②. 当某个位桶中的链表长度达到8，即将进行链表转红黑树时，会检查总位桶的数量是否小于64，如果总数量小于64也会进行扩容；

③. 当创建一个HashMap对象之后，第一次往HashMap里面进行put操作时，也会先进行扩容；

④. 另外在HashMap的put方法中，当HashMap的size(实际键值对个数)达到 threshold(阈值)时，也会触发扩容操作。

3. resize()扩容方法源码

了解了HashMap的扩容时机之后，我们来看看这个扩容操作具体是怎么实现的，源码如下：

    final Node<K,V>[] resize() 
        //扩容前的Node数组，先保存 table 副本，接下来 copy 到新数组用
        Node<K,V>[] oldTab = table;
        //当前 table 的容量，是 length 而不是 size
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //当前桶的大小
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 计算新的容量值和下一次要扩展的容量
        if (oldCap > 0) 
        //如果当前容量大于 0，也就是非第一次初始化的情况(扩容场景下)
            if (oldCap >= MAXIMUM_CAPACITY) 
            // 当超过最大值，则直接使用最大值作为扩容最大限度，以后就不再扩充了
                threshold = Integer.MAX_VALUE;
                return oldTab;
            
            // 没超过最大值，就扩充为原来的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        
        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);
        
        // 计算新的resize上限
        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) 
            // 把每个bucket都移动到新的buckets中
            for (int j = 0; j < oldCap; ++j) 
                Node<K,V> e;
                //如果位置上没有元素，直接为null
                if ((e = oldTab[j]) != null) 
                    oldTab[j] = null;
                    //如果只有一个元素，新的hash计算后放入新的数组中
                    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;
                            //hash碰撞后高位为0，放入低Hash值的链表中
                            if ((e.hash & oldCap) == 0) 
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            
                            //hash碰撞后高位为1，放入高Hash值的链表中
                            else 
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            
                         while ((e = next) != null);
                        // 低hash值的链表放入数组的原始位置
                        if (loTail != null) 
                            loTail.next = null;
                            newTab[j] = loHead;
                        
                        // 高hash值的链表放入数组的原始位置 + 原始容量
                        if (hiTail != null) 
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        
                    
                
            
        
        
        return newTab;

在这段源码中，壹哥 把核心代码都做了中文注释，大家可以参考着阅读理解。

4. HashMap扩容流程

上面的resize源码看起来挺让人头疼的，所以我们可以对其进行简单梳理，归纳如下图所示，大家可以结合上面的源码和下图理解resize扩容过程。

​

5. 扩容机制原理(重点)

对HashMap的扩容过程有了基本的了解之后，我们再来看看扩容机制的底层实现原理。

我们知道，HashMap存储结构的主体是一个table数组，但Java中没有真正的动态数组。也就是说，数组初始化的时候是多大，那它就一直是多大。那扩容是怎么实现的呢？答案就是HashMap会创建一个新的更大的数组，将旧数组中的数据拷贝过去，用这个新数组代替已有的旧数组。这就好比一开始我们用一个小桶装水，后来想要装更多的水，就得换一个更大的水桶，就是基于这样的思路。

HashMap的扩容机制实现的很巧妙，可以用最小的性能消耗来完成扩容工作，但其内部在进行数据拷贝的时候需要考虑如下几种情况:

①. 如果节点的 next属性 为null，则说明这是一个最正常的节点，不是桶内链表，也不是红黑树，这样的节点可以直接计算索引位置，然后插入。

②. 如果是一颗红黑树，会使用split方法进行处理，原理就是将红黑树拆分成两个TreeNode链表，然后判断每个链表的长度是否<=6，如果是，就将TreeNode转换成桶内链表，否则再转换成红黑树。

③. 如果是桶内链表，则将链表拷贝到新数组中，保证链表的顺序不变。

三. 扩容后的rehash操作

1. rehash操作简介

HashMap在数组扩容后，还需要进行一次新的rehash操作，以此来重新确定元素的存放位置。在rehash之后，元素的存放位置要么是在原位置，要么是在原位置的基础上 向下移动 之前容量个数 的位置。比如，上次容量是16，下次扩容后容量变成了16+16=32。如果一个元素原先在下标为7的位置上，那么扩容后，该元素要么还在7的位置上，要么就在7+16的位置上。

2. rehash实现过程(重点)

有的小伙伴可能会问，为什么要这样呢？下面 壹哥 来解释一下Java 8的扩容机制是怎么做到这一点的。

2.1 扩容之前的hash过程

假设扩容前的数据结构如下图所示：

​

此时我们有一个HashMap，在数组索引为5的位置上产生了一个链表，依次存储着2个key，分别为7、5。

假设此时HashMap的容量是默认的16，我们把容量设置为n，即n=16，key1、key2分别表示7、5这两个key，hash1、hash2分别是key1、key2对应的hash值。

那么此时在扩容之前，n-1与hash1进行与运算，n-1与hash2进行与运算的结果如下图所示：

​

经过与运算，我们会发现，在HashMap容量为16时，key1与key2与运算的结果相同，最终的结果都是在5这个位置上，运算过程如下：

n-1 也就是二进制的 0000 1111 = 1+2+4+8 = 15

key1 哈希值的最后 8 位为 0001 0101；

key2 哈希值的最后 8 位为0000 0101(和 key1 不同)；

与运算后发生了哈希冲突，索引都在 0000 0101 =5 位置上。

2.2 扩容之后的hash过程

接下来我们将HashMap进行2倍扩容，那么此时HashMap的容量变成32，即n=32，接下来继续把n-1与hash1进行与运算，n-1与hash2进行与运算。

​

我们会发现，此时计算的结果，key1与运算的结果是21，key2与运算的结果依然是5，运算过程如下：

n-1 也就是二进制的 0001 1111 = 1+2+4+8+16 = 31，扩容前是 0000 1111 = 15；

key1 哈希值的低位为 0001 0101；

key2 哈希值的低位为 0000 0101(和 key1 不同)；

key1 做与运算后，索引为 0001 0101 = 21。

key2 做与运算后，索引为 0000 0101 = 5。

此时HashMap中存储数据的结构图如下所示：

​

所以扩容后，key1的索引就变成了 21 (1 0101)，也就是 5+16，即 原来的索引+原来的容量。我们可以用下图表示：

​

因此，JDK 8中HashMap扩容时，不需要像JDK 7 那样重新计算hash值，只需要看原来的hash值新增的bit位是1还是0就好了。是0，则表示索引没变，是1，则表示索引变成了 “原索引+oldCap”。我们可以参照下图中，容量16扩充为32的resize示意图:

​

对于hash值的高位是否为1，只需要和扩容后的长度 做 与运算 就可以知道了。因为扩容后的长度是2的n次方，所以高位必为1，低位必为0，如10000这种形式，源码中是通过 e.hash & oldCap 来实现这个逻辑的。

这个设计非常的巧妙，既省去了重新计算hash值的时间，同时由于新增的1 bit是0 还是1可以认为是随机的，因此resize的过程中，也把之前出现冲突的节点均匀地分散到了新的位桶中，这一块就是JDK 8中新增的优化点。

另外还有一点需要我们注意，JDK 7中进行rehash的时候，旧链表迁移到新链表的时候，如果新链表所在的数组索引位置相同，则链表元素会倒置，但是JDK 8中不会出现倒置现象。

四. 结语

好了，到此为止，壹哥 就带各位把HashMap的扩容机制、rehash的原理 复习完毕，可以说这是目前为止最难搞、也最复杂的一个知识点了，不知道你有么有看明白呢？若有收获，请给壹哥点个赞吧。