Hash 冲突（哈希碰撞）

Hash 冲突（哈希碰撞）

1. 什么是 Hash 冲突？

Hash 冲突（哈希碰撞） 发生在两个或多个不同的 Key 计算出的哈希值相同，导致它们映射到 Hash 表的同一索引位置。

举个例子，假设 hash(key) % 16 计算出的索引：

Key1 -> index 3
Key2 -> index 3  （冲突）

此时，Key1 和 Key2 发生冲突，需要采取冲突解决策略。

2. 解决 Hash 冲突的方法

常见的解决方式有以下几种：

1. 链地址法（拉链法）（JDK 8 及以上：链表 + 红黑树）
2. 开放地址法（线性探测、二次探测、双重散列）
3. 再哈希法
4. 扩展哈希法（用于数据库索引）

3. HashMap 采用的 Hash 冲突解决方案

在 Java 的 HashMap 中，主要使用 链地址法（拉链法），在 JDK 8 之后优化为 链表 + 红黑树 结构。

🔹 JDK 7 及以前：链表解决 Hash 冲突

原理：相同哈希值的 Key 以链表存储在同一个数组槽位上。

table = [
    0 -> null
    1 -> {Key1, Value1} -> {Key2, Value2} -> {Key3, Value3}  (链表)
    2 -> null
]

当查询 Key2 时，需要从 Key1 开始顺序遍历链表，时间复杂度接近 O(n)。

🔹 JDK 8 及以后：链表 + 红黑树优化

优化点：当链表长度 > 8 时，自动转换为 红黑树，提升查找效率。

table = [
    0 -> null
    1 -> {Key1, Value1} -> {Key2, Value2} -> {Key3, Value3}  (链表, size < 8)
    2 -> {Key4, Value4} -> {Key5, Value5} -> {Key6, Value6} -> {Key7, Value7} -> {Key8, Value8} -> {Key9, Value9}  (红黑树, size ≥ 8)
]

• 链表查询：O(n)
• 红黑树查询：O(log n)（提高查询效率）

🔹 红黑树的触发条件

1. 当链表长度 ≥ 8 时，链表转红黑树。
2. 当红黑树节点 ≤ 6 时，树重新转回链表（节省空间）。

4. 其他 Hash 冲突解决方案

（1）开放地址法

不使用链表，而是在 Hash 表中寻找下一个空闲位置存放数据。

• 线性探测法（Linear Probing）：

  index = (hash + step) % table.length
  

  若发生冲突，就尝试 index + 1 继续寻找空槽位，直到找到空位。

• 二次探测法（Quadratic Probing）：

  index = (hash + step²) % table.length
  

  步长是平方关系，避免数据过度聚集。

• 双重哈希（Double Hashing）：

  index = (hash1 + step * hash2) % table.length
  

  计算两个哈希值，减少冲突。

（2）再哈希法

发生冲突时，使用另一个哈希函数重新计算索引，直到找到空槽。

index = rehash(key) % table.length

适用于 哈希函数质量较低 的情况。

（3）扩展哈希法

数据库索引（如 B+ 树）使用 动态扩容 方式来减少冲突。

5. 总结

最佳实践（JDK 8 HashMap）：

• 小数据量：链表
• 冲突严重（链表长度 ≥ 8）：红黑树
• 多线程环境：ConcurrentHashMap

6. 面试重点

1. JDK 7 和 JDK 8 的 HashMap 在哈希冲突处理上有何不同？

   • JDK 7：数组 + 链表，查询性能 O(n)。
   • JDK 8+：链表长度 ≥ 8 转红黑树，查询性能 O(log n)。

2. 什么情况下 HashMap 需要扩容？

   • 当元素个数 > capacity * loadFactor 时（默认 0.75）。
   • 触发 rehash（重新计算哈希值，数据搬移），容量翻倍。

3. HashMap 为什么线程不安全？

   • 多线程同时 put() 可能导致死循环（JDK 7）。
   • 扩容（resize）过程可能数据丢失。

7. 代码示例

import java.util.HashMap;

public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();

        // 插入数据，模拟 Hash 冲突
        map.put(1, "A");
        map.put(17, "B");  // 1 和 17 的哈希值相同（假设 table 长度为 16）
        map.put(33, "C");  // 发生冲突，形成链表

        System.out.println(map);
    }
}

输出

{1=A, 17=B, 33=C}

🔹 示例说明：

• 1, 17, 33 发生哈希冲突，映射到同一索引位置，形成链表（或红黑树）。
• JDK 8 以后，若链表长度 ≥ 8，会转为红黑树，提升查找效率。

总结

1. Hash 冲突是不可避免的，但可以通过 链表 + 红黑树 解决。
2. JDK 8 及以上的 HashMap 优化了冲突处理：
   • 小冲突（链表）：O(n)
   • 大冲突（红黑树）：O(log n)
3. 多线程环境请使用 ConcurrentHashMap，避免 HashMap 的线程安全问题。 🚀