深入理解HashMap：Hash冲突的解决机制

原创已于 2025-04-26 15:49:39 修改 · 1.2k 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#哈希算法 #算法

于 2025-04-26 15:49:06 首次发布

引言

HashMap 是 Java 集合框架中最常用的数据结构之一，它通过键值对的形式存储数据，并利用哈希算法实现高效的插入、删除和查询操作。然而，在实际使用中，由于哈希函数的有限性和哈希桶数量的限制，不可避免地会出现 哈希冲突（即不同的键映射到同一个哈希桶）。本文将深入探讨 HashMap 如何解决哈希冲突，并结合源码和 Mermaid 图表帮助你更好地理解其工作机制。

一、什么是哈希冲突？

哈希冲突是指两个或多个不同的键通过哈希函数计算后，被映射到同一个哈希桶中的情况。例如，假设我们有一个简单的哈希函数：

hash(key) = key % 10

如果键 12 和 22 同时插入到哈希表中，它们都会被映射到索引 2 的位置，从而引发哈希冲突。

为了解决这个问题，HashMap 使用了两种主要策略：

链地址法（Chaining）：在每个哈希桶中使用链表或红黑树存储冲突的元素。
开放地址法（Open Addressing）：通过探测其他空闲的桶来存储冲突的元素（Java 的 HashMap 并未采用此方法）。

Java 的 HashMap 主要采用 链地址法 来解决哈希冲突。

二、HashMap 的内部结构

1. 数据结构概览

HashMap 的底层实现基于数组 + 链表/红黑树的混合结构：

数组：称为哈希桶（Bucket），用于存储键值对的引用。
链表：当发生哈希冲突时，冲突的键值对会以链表的形式存储在同一个桶中。
红黑树：当链表长度超过一定阈值（默认为8）且数组长度达到一定条件时，链表会转换为红黑树以提高查询效率。

2. 关键参数

初始容量（Initial Capacity）：默认为 16（2^4）。
负载因子（Load Factor）：默认为 0.75，表示哈希表在扩容前允许的最大填充比例。
扩容阈值（Threshold）：capacity * load factor，当元素数量超过该值时，触发扩容。

三、解决哈希冲突的核心机制

1. 链地址法

链地址法是 HashMap 解决哈希冲突的主要方式。当多个键映射到同一个桶时，这些键值对会被存储在一个链表中。如果链表长度超过阈值（默认为 8），链表会转换为红黑树以优化查询性能。

以下是 HashMap 中处理冲突的关键代码片段：

static class Node<K, V> implements Map.Entry<K, V> {
    final int hash;
    final K key;
    V value;
    Node<K, V> next; // 指向下一个节点，形成链表

    Node(int hash, K key, V value, Node<K, V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey() { return key; }
    public final V getValue() { return value; }
    public final String toString() { return key + "=" + value; }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (!(o instanceof Map.Entry)) return false;
        Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
        return Objects.equals(key, e.getKey()) &&
               Objects.equals(value, e.getValue());
    }

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }
}

2. 红黑树优化

当链表长度超过阈值（默认为 8）且数组长度达到 64 时，链表会转换为红黑树。以下是红黑树节点的定义：

static final class TreeNode<K, V> extends LinkedHashMap.Entry<K, V> {
    TreeNode<K, V> parent;  // 父节点
    TreeNode<K, V> left;    // 左子节点
    TreeNode<K, V> right;   // 右子节点
    TreeNode<K, V> prev;    // 前驱节点，用于删除操作
    boolean red;            // 是否为红色节点

    TreeNode(int hash, K key, V value, Node<K, V> next) {
        super(hash, key, value, next);
    }

    // 其他红黑树相关方法...
}

3. 插入与查找过程

插入和查找时，HashMap 首先通过哈希函数计算键的索引位置，然后根据该位置的桶是否存在冲突进行处理：

如果桶为空，则直接插入新节点。
如果桶中存在冲突，则遍历链表或红黑树查找目标键。

以下是插入操作的部分源码：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K, V>[] tab;
    Node<K, V> p;
    int n, i;

    // 初始化哈希表
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;

    // 计算索引位置并检查是否为空
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K, V> e;
        K k;

        // 检查是否为重复键
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
        else {
            // 遍历链表查找目标键
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // 转换为红黑树
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }

        // 更新已有键的值
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;

    // 检查是否需要扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}