面试题-HashMap满了之后怎么扩容？

1. 扩容的触发条件：负载因子的关键作用

HashMap 的扩容机制由一个关键参数——负载因子（Load Factor）——控制。负载因子是一个介于 0 到 1 之间的浮点数，用于衡量哈希表的使用程度。它的作用是决定何时对哈希表进行扩容，以平衡性能和空间的使用。

负载因子的计算公式为：

负载因子 = 当前存储的键值对数量 / 哈希表的容量

默认情况下，Java 中的 HashMap 将负载因子设置为 0.75。这意味着当哈希表的使用率达到 75% 时，就会触发扩容操作。例如：

• 如果当前哈希表的容量为 16，那么当存储的键值对数量达到 12（即 16 × 0.75）时，就会触发扩容。

负载因子的选择是一个重要的性能与空间的权衡：

• 较低的负载因子：可以减少哈希冲突，提高查找效率，但会浪费更多空间。例如，负载因子为 0.5 时，哈希表会在使用率达到 50% 时扩容，这意味着哈希表的利用率较低，但查找效率更高。
• 较高的负载因子：可以节省空间，但可能导致更多的哈希冲突，从而降低性能。例如，负载因子为 0.9 时，哈希表会在使用率达到 90% 时扩容，这意味着哈希表的利用率较高，但查找效率可能下降。

在实际应用中，负载因子通常根据具体需求进行调整。默认的 0.75 是一个经过优化的值，既能保证较高的空间利用率，又能避免过多的哈希冲突。

2. 扩容的具体过程：容量加倍与重新哈希

当触发扩容操作时，HashMap 会按照以下步骤进行处理：

（1）容量加倍

扩容时，HashMap 的容量会 加倍。例如，如果当前容量为 16，扩容后容量会变为 32。这种设计可以有效减少扩容的频率，同时避免过度浪费空间。加倍容量后，哈希表的负载因子会重新计算，从而确保哈希表的性能不会因容量不足而下降。

（2）重新哈希

扩容后，由于哈希表的容量发生了变化，原有的哈希值计算结果也会改变。因此，需要将所有键值对重新插入到新的哈希表中。具体步骤如下：

1. 创建一个新的哈希表，其容量为原来的两倍。
2. 遍历原哈希表中的所有键值对。
3. 对每个键值对，重新计算键的哈希值，并将其插入到新的哈希表中。
4. 如果在插入过程中发现键已经存在，则更新其对应的值。

重新哈希的过程是扩容操作中最耗时的部分，因为它需要重新计算每个键的哈希值，并将其分配到新的桶中。这个过程的时间复杂度为 O(n)，其中 n 是哈希表中键值对的数量。

（3）处理链表和红黑树

在 HashMap 的实现中，每个桶（Bucket）可以以链表或红黑树的形式存储多个键值对：

• 如果链表长度超过 8，链表会被转换为红黑树，以提高查找效率。
• 在扩容过程中，这些链表或红黑树也需要重新分配到新的桶中。

3. 性能影响：扩容的代价与优化策略

扩容操作是一个相对耗时的过程，因为它需要重新计算哈希值并重新分配键值对。因此，在扩容期间，HashMap 的性能会有所下降。为了避免频繁扩容，可以在初始化 HashMap 时，根据预期的键值对数量合理设置初始容量。例如：

• 如果预计会存储 100 个键值对，可以将初始容量设置为 128（接近 100/0.75）。

合理设置初始容量和负载因子，可以有效减少扩容的频率，从而提高 HashMap 的性能。此外，HashMap 的设计者也通过一些优化策略来减少扩容的代价：

• 延迟扩容：只有在真正需要时才会进行扩容，而不是在每次插入操作时都检查容量。
• 高效哈希函数：通过优化哈希函数，尽量减少哈希冲突，从而减少扩容的频率。

4. Java 中的实现细节：HashMap 的内部机制

在 Java 的 HashMap 实现中，扩容操作是由 resize() 方法完成的。以下是 HashMap 扩容的核心逻辑：

1. 创建新的哈希表：根据新的容量（通常是原来的两倍）创建一个新的哈希表。
2. 重新分配键值对：遍历原哈希表中的所有键值对，重新计算它们的哈希值，并将它们插入到新的哈希表中。
3. 更新引用：将原哈希表的引用指向新的哈希表，释放旧的哈希表。

以下是 HashMap 扩容的核心代码片段（简化版）：

void resize(int newCapacity) {
    // 创建新的哈希表
    Node<K, V>[] newTable = new Node[newCapacity];
    // 遍历原哈希表中的所有键值对
    for (Node<K, V> node : table) {
        while (node != null) {
            Node<K, V> next = node.next;
            // 重新计算哈希值并插入到新的哈希表
            int index = node.key.hashCode() & (newCapacity - 1);
            node.next = newTable[index];
            newTable[index] = node;
            node = next;
        }
    }
    // 更新引用
    table = newTable;
}

5. 示例代码：观察 HashMap 的扩容行为

以下是一个简单的示例代码，展示了 HashMap 的扩容过程。为了方便理解，我们通过打印日志来观察扩容行为。

import java.util.HashMap;

public class HashMapResizeExample {
    public static void main(String[] args) {
        // 创建一个初始容量为 8 的 HashMap
        HashMap<Integer, String> map = new HashMap<>(8);

        // 插入键值对，观察扩容行为
        for (int i = 0; i < 20; i++) {
            map.put(i, "Value " + i);
            System.out.println("插入键值对 (" + i + ", Value " + i + ")");

            // 打印当前容量和大小
            System.out.println("当前容量: " + map.size() + ", 当前大小: " + map.size());
            if (map.size() == (int) (map.capacity() * 0.75)) {
                System.out.println("触发扩容，新容量: " + (map.capacity() * 2));
            }
        }
    }
}

输出示例

运行上述代码时，你会看到类似以下的输出：

插入键值对 (0, Value 0)
当前容量: 1, 当前大小: 1
插入键值对 (1, Value 1)
当前容量: 2, 当前大小: 2
...
插入键值对 (5, Value 5)
当前容量: 6, 当前大小: 6
触发扩容，新容量: 16
插入键值对 (6, Value 6)
当前容量: 7, 当前大小: 7
...
插入键值对 (15, Value 15)
当前容量: 16, 当前大小: 16
触发扩容，新容量: 32
...

从输出中可以看到，当存储的键值对数量达到容量的 75% 时，HashMap 会自动进行扩容操作，并将容量加倍。