Java面试必备：Java中HashMap的扩容机制详解-CSDN博客

本文链接：https://blog.csdn.net/qq_58299462/article/details/147627751

Java面试题 - Java 中HashMap的扩容机制是怎样的?

回答重点

HashMap中的广容是基于负载因子(oadfactor)来决定的。默认情况下，HashMap的负载因子为0.75，这意味着当HashMap的已存储元素数量超过当前容量的75%时，就会触发扩容操作。

例如，初始容量为16,负载因子为0.75,则扩容阈值为16x0.75=12。当存入第13个元素时,HashMap就会触发扩容。

当触发扩容时，HashMap的容量会扩大为当前容量的两倍。例如，容量从16增加到32,从32增加到64等。

扩容时，HashMap需要重新计算所有元素的哈希值，并将它们重新分配到新的哈希桶中，这个过程称为rehashing。每个元素的存储位置会根据新容量的大小重新计算哈希值，并移动到新的数组中。

引言

HashMap是Java集合框架中最常用的数据结构之一，它基于哈希表实现，提供了高效的键值对存储和检索功能。理解HashMap的扩容机制对于编写高性能Java应用至关重要。本文将深入探讨HashMap的扩容原理、触发条件及具体实现过程。

一、HashMap基础结构

HashMap在Java 8之前采用"数组+链表"的实现方式，在Java 8及以后版本中，当链表长度超过阈值(默认为8)时，链表会转换为红黑树，以提高查询效率。

二、扩容触发条件

HashMap扩容主要发生在以下两种情况下：

元素数量超过阈值：当HashMap中存储的键值对数量超过容量×负载因子时触发扩容
- 默认负载因子(loadFactor)为0.75
- 默认初始容量为16
链表长度过长：在Java 8+中，当某个桶中的链表长度超过8，但数组长度小于64时，会选择扩容而不是树化

三、扩容过程详解

1. 扩容基本流程

2. 具体步骤

计算新容量：新容量为旧容量的2倍
```
newCap = oldCap << 1
```

创建新数组：根据新容量创建新的Node数组

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

元素迁移：
- 遍历旧数组中的每个桶
- 对于每个桶中的元素，重新计算其在新数组中的位置
- Java 8优化：元素在新数组中的位置要么是原位置，要么是原位置+旧容量
更新阈值：新的阈值为新容量乘以负载因子
```
threshold = (int)(newCap * loadFactor);
```

3. 元素重新哈希的优化

Java 8对重新哈希过程进行了优化，利用哈希值的特性减少计算：

这种优化基于以下原理：扩容后容量是原来的2倍，因此元素的新位置要么是原位置，要么是原位置加上旧容量。

四、源码分析

让我们看看Java 17中HashMap扩容的核心代码(resize()方法片段)：

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    
    // 计算新容量和新阈值
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // 双倍阈值
    }
    // ... 其他情况处理
    
    // 迁移元素
    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 {
                    // 链表优化重哈希
                    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;
}

五、性能影响与最佳实践

扩容的性能开销：
- 扩容需要重新哈希所有元素，时间复杂度为O(n)
- 在性能敏感的场景中，应尽量避免频繁扩容
优化建议：
- 预估元素数量，在创建HashMap时指定初始容量
```
// 预计存储100个元素
Map<String, String> map = new HashMap<>(128); // 128 > 100/0.75
```
- 根据实际情况调整负载因子(0.75是时间与空间的平衡值)
扩容与并发：
- HashMap不是线程安全的，扩容时可能导致并发问题
- 多线程环境下应使用ConcurrentHashMap