HashMap底层实现--扩容

最新推荐文章于 2023-07-16 17:21:41 发布

lxxxxxt

最新推荐文章于 2023-07-16 17:21:41 发布

阅读量363

点赞数

分类专栏： Java 面经问题总结

本文链接：https://blog.csdn.net/qq_36281031/article/details/105176671

版权

Java 同时被 2 个专栏收录

47 篇文章 1 订阅

订阅专栏

面经问题总结

18 篇文章 0 订阅

订阅专栏

在 HashMap 中，桶数组的长度均是2的幂，阈值大小为桶数组长度与负载因子的乘积。当 HashMap 中的键值对数量超过阈值时，进行扩容。
HashMap 的扩容机制与其他变长集合的套路不太一样，HashMap 按当前桶数组长度的2倍进行扩容，阈值也变为原来的2倍（如果计算过程中，阈值溢出归零，则按阈值公式重新计算）。扩容之后，要重新计算键值对的位置，并把它们移动到合适的位置上去。

1 源码：

源码分为三大块：

计算新桶数组的容量 newCap 和新阈值 newThr（第一个if分支，详细过程见注释）
根据计算出的 newCap 创建新的桶数组，桶数组 table 也是在这里进行初始化的（newTab，一行代码）
将键值对节点重新映射到新的桶数组里。如果节点是 TreeNode 类型，则需要拆分红黑树。如果是普通节点，则节点按原顺序进行分组。

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 如果 table 不为空，表明已经初始化过了，则调整容量和阈值
    if (oldCap > 0) {
        // 当 table 容量超过容量最大值，则不再扩容
        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;   //移位可能导致溢出
    //oldCap == 0，oldThr > 0 ,调用 HashMap(int) 和 HashMap(int, float) 构造方法时会产生这种情况
    } else if (oldThr > 0){
    	//oldThr = tableSizeFor(initialCapacity);里面保存了初始容量值
        newCap = oldThr;   
    }
    //桶数组未被初始化（调用无参构造方法），则按默认值初始化newCap, newThr
    else {               
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    
    /* newThr 为 0 时,即上一个条件分支未计算 newThr 
    *或嵌套分支在计算过程中导致 newThr 溢出归零,
    *按阈值计算公式进行计算
    */
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    
    // 创建新的桶数组，桶数组的初始化也是在这里完成的
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 如果旧的桶数组不为空，则遍历桶数组，并将键值对映射到新的桶数组中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                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;
                        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;
}

2 键值对节点的重新映射

对于链表类型节点，则需先对链表进行分组，然后再映射。需要的注意的是，分组后，组内节点相对位置保持不变。
对于树形节点，需先拆分红黑树再映射。

链表类型：

将原本在一条链表中的元素分组后，重新映射；由于原hash = hash & (n - 1)，例如n = 8，那么只有后三位参与了求余，扩容后newCap = 16，hash值重映射时后4位参与求余，过程如下：
映射前：
重新映射过程如下: 依次遍历链表，并计算节点 hash & oldCap 的值。

如果值为0，将 loHead 和 loTail 指向这个节点。如果后面还有节点 hash & oldCap 为0的话，则将节点链入 loHead 指向的链表中，并将 loTail 指向该节点。如果值为非0的话，则让 hiHead 和 hiTail 指向该节点。完成遍历后，可能会得到两条链表，此时就完成了链表分组：

JDK1.7会重新计算hash，这个方式是相对耗性能的，而在1.8中对这一步进行了优化。newTab[j + oldCap] = hiHead;，因为扩容后要么是在原位置，要么是在 oldCap + 原位置（因为扩容为原来的二倍，所以只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”）
得到的结果与hash运算得到的结果是一致的，只是会更块。

最后再将这两条链接存放到相应的桶中，完成扩容。如下图：

重新映射后，两条链表中的节点顺序并未发生变化，还是保持了扩容前的顺序（JDK1.7迁移到新表时链表会反转？）。
JDK 1.8 版本下 HashMap 扩容效率要高于之前版本。如果大家看过 JDK 1.7 的源码会发现，JDK 1.7 为了防止因 hash 碰撞引发的拒绝服务攻击，在计算 hash 过程中引入随机种子。以增强 hash 的随机性，使得键值对均匀分布在桶数组中。在扩容过程中，相关方法会根据容量判断是否需要生成新的随机种子，并重新计算所有节点的 hash。而在 JDK 1.8 中，则通过引入红黑树替代了该种方式。从而避免了多次计算 hash 的操作，提高了扩容效率。