HashMap 底层原理详解,从数组、链表到红黑树

在 Java 开发中,HashMap 可以说是使用频率非常高的集合类。

无论是保存用户信息、统计数据,还是进行数据缓存,我们经常都会使用到 HashMap。

例如:

arduino 复制代码
Map<String, Integer> map = new HashMap<>();

map.put("Java", 1);
map.put("Python", 2);
map.put("Go", 3);

System.out.println(map.get("Java"));

代码非常简单,但是你有没有想过几个问题:

  • HashMap 为什么查询速度比较快?
  • HashMap 底层到底是怎么存储数据的?
  • 为什么 HashMap 使用数组和链表?
  • 为什么 JDK 1.8 又引入了红黑树?
  • HashMap 的扩容机制是怎样的?

今天就结合 JDK 1.8 的源码,聊聊 HashMap 的底层实现。

一、HashMap 的底层数据结构

在 JDK 1.8 中,HashMap 底层主要使用:

数组 + 链表 + 红黑树

可以先看一下整体结构:

sql 复制代码
                 HashMap
                    |
             Node<K,V>[] table
                    |
       +------------+------------+
       |            |            |
     Node         Node          null
       |            |
      Node         Node
       |            |
      Node       红黑树结构

这里的数组就是 HashMap 的主体结构。

每个数组元素可以存储一个 Node 节点。

当多个 Key 计算出来的数组下标相同时,就会发生哈希冲突。

JDK 1.8 中,发生冲突时,通常会通过链表的方式连接这些节点。

当链表长度达到一定条件,并且数组容量满足要求时,链表就可能转换成红黑树。

那么,为什么要这样设计呢?

原因主要是为了提高数据查询和插入的效率。

数组可以通过下标快速定位,链表可以解决哈希冲突,而红黑树则可以优化冲突严重时的查询效率。

二、HashMap 的 put() 方法是如何工作的?

我们平时使用 HashMap,最常见的操作就是 put()。

例如:

arduino 复制代码
Map<String, Integer> map = new HashMap<>();

map.put("Java", 100);

这行代码执行时,HashMap 内部大致会经历以下几个步骤:

  1. 根据 Key 计算 Hash 值。
  2. 根据 Hash 值计算数组下标。
  3. 判断数组对应位置是否为空。
  4. 如果为空,直接插入节点。
  5. 如果不为空,则判断是否存在相同的 Key。
  6. 如果存在相同 Key,则替换 Value。
  7. 如果不存在,则将新节点加入链表或红黑树。
  8. 根据条件判断是否需要扩容。

我们先看看 HashMap 中计算 Hash 值的核心代码:

java 复制代码
static final int hash(Object key) {
    int h;

    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

这里有一个比较有意思的操作:

scss 复制代码
h ^ (h >>> 16)

为什么要这样计算?

因为 Java 中 hashCode() 返回的是一个 int 类型的哈希值。

HashMap 将高 16 位与低 16 位进行异或运算,让高位信息也参与低位计算,从而帮助减少部分哈希冲突。

接下来,通过计算结果获取数组下标:

bash 复制代码
(n - 1) & hash

这里的 n 就是数组长度。

例如,数组长度为 16,那么:

ini 复制代码
index = (16 - 1) & hash;

为什么不用取模运算?

因为 HashMap 的数组长度始终保持为 2 的幂次方,使用位运算可以更高效地计算数组下标。

三、什么是 HashMap 的哈希冲突?

了解 put() 的过程之后,还需要理解一个重要概念:哈希冲突。

所谓哈希冲突,就是不同的 Key 经过哈希计算后,最终得到相同的数组下标。

例如:

rust 复制代码
数组下标:

0
1  -> Java
2
3  -> Python -> Go -> PHP
4
5

假设 Java、Python、Go、PHP 经过计算后,都落在数组下标 3 的位置。

那么这些数据就需要通过链表连接起来。

这就是 HashMap 使用链表解决哈希冲突的基本原理。

需要注意,哈希冲突不代表 Key 一定相同。

例如:

ini 复制代码
String key1 = "Aa";
String key2 = "BB";

System.out.println(key1.hashCode());
System.out.println(key2.hashCode());

这两个字符串的 hashCode() 都是 2112。

但它们显然不是同一个字符串。

因此,HashMap 判断 Key 是否相同时,不能只依赖 hashCode(),还需要进一步判断 equals()。

四、为什么 JDK 1.8 引入红黑树?

在 JDK 1.7 中,HashMap 主要使用数组和链表解决哈希冲突。

但是,如果大量 Key 都发生哈希冲突,那么链表就会越来越长。

当链表长度较长时,查询数据就需要逐个遍历节点,最坏情况下时间复杂度为 O(n)。

为了解决这个问题,JDK 1.8 引入了红黑树。

红黑树是一种自平衡二叉搜索树,可以通过旋转和变色维持树的平衡。

在正常情况下,红黑树的查询时间复杂度为 O(log n)。

HashMap 中有几个比较重要的常量:

arduino 复制代码
static final int TREEIFY_THRESHOLD = 8;

static final int UNTREEIFY_THRESHOLD = 6;

static final int MIN_TREEIFY_CAPACITY = 64;

它们分别代表:

常量 默认值 作用
TREEIFY_THRESHOLD 8 链表达到树化判断阈值
UNTREEIFY_THRESHOLD 6 扩容拆分时判断是否退化为链表
MIN_TREEIFY_CAPACITY 64 允许链表树化的最小数组容量

这里有一个容易理解错的地方:

链表长度达到 8,并不意味着一定会转换成红黑树。

如果当前数组容量还没有达到 64,HashMap 会优先尝试扩容,而不是直接树化。

这样设计是为了减少不必要的红黑树转换。

五、HashMap 的扩容机制

HashMap 还有一个比较重要的机制:扩容。

在 JDK 1.8 中,HashMap 默认初始容量为 16,默认负载因子为 0.75。

arduino 复制代码
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

static final float DEFAULT_LOAD_FACTOR = 0.75f;

那么什么时候会发生扩容?

假设:

  • 初始容量:16
  • 负载因子:0.75

那么扩容阈值就是:

ini 复制代码
16 × 0.75 = 12

当 HashMap 中元素数量超过扩容阈值时,就会触发扩容。

扩容之后,数组容量通常变成原来的两倍:

复制代码
扩容前:16

扩容后:32

为什么要扩容?

因为数组容量越小,多个 Key 落在相同数组下标的概率通常越高。

适当扩大数组容量,可以降低哈希冲突的概率。

不过,扩容也不是没有代价。

扩容时需要重新分配数组,并处理原有节点的位置,因此会产生一定的性能开销。

JDK 1.8 对扩容过程做了一些优化。

它不需要像传统方式那样对每个节点重新计算完整的哈希下标,而是可以根据原容量对应的那一位判断节点是否需要移动。

例如:

arduino 复制代码
if ((e.hash & oldCap) == 0) {
    // 节点留在原位置
} else {
    // 节点移动到原位置 + oldCap
}

这里的 oldCap 就是扩容之前的数组容量。

这种方式可以减少扩容过程中不必要的计算。

六、HashMap 为什么不保证线程安全?

在使用 HashMap 时,还需要注意一个问题:

HashMap 是非线程安全的集合类。

如果多个线程同时修改同一个 HashMap,可能出现数据覆盖、数据丢失等问题。

例如:

ini 复制代码
Map<String, Integer> map = new HashMap<>();

Thread t1 = new Thread(() -> {
    map.put("A", 1);
});

Thread t2 = new Thread(() -> {
    map.put("B", 2);
});

t1.start();
t2.start();

这段代码虽然看起来很简单,但如果多个线程同时执行修改操作,HashMap 并没有提供必要的同步保护。

那么,如果业务中确实需要在多线程环境下使用 Map,应该怎么办?

通常有两种选择。

1. 使用 Collections.synchronizedMap()

arduino 复制代码
Map<String, Integer> map =
        Collections.synchronizedMap(new HashMap<>());

这种方式可以通过同步机制保护 Map 的操作。

2. 使用 ConcurrentHashMap

arduino 复制代码
Map<String, Integer> map = new ConcurrentHashMap<>();

map.put("Java", 100);
map.put("Python", 200);

ConcurrentHashMap 是 Java 并发包中提供的线程安全 Map 实现。

在高并发场景下,通常优先考虑 ConcurrentHashMap。

另外需要注意,即使使用线程安全的 Map,多个操作组合起来也不一定天然具有原子性,具体还需要根据业务使用相应的原子操作。

七、HashMap 常见面试问题

最后整理几个 HashMap 比较常见的问题。

1. HashMap 的默认初始容量是多少?

默认初始容量为 16。

2. HashMap 的默认负载因子是多少?

默认负载因子为 0.75。

3. HashMap 为什么数组长度必须是 2 的幂次方?

因为这样可以使用位运算快速计算数组下标,同时也有利于扩容时优化节点迁移过程。

4. HashMap 可以存储 null 吗?

可以。

HashMap 允许一个 null Key,也允许多个 Value 为 null。

5. HashMap 为什么查询速度比较快?

因为可以通过 Key 的哈希值快速定位数组下标,正常情况下查询效率较高。

6. JDK 1.8 中 HashMap 的数据结构是什么?

数组 + 链表 + 红黑树。

7. HashMap 是线程安全的吗?

不是。如果需要线程安全的 Map,可以考虑 ConcurrentHashMap。

相关推荐
未秃头的程序猿33 分钟前
RedisTemplate 序列化用错,线上多了 3 个 G 的隐形 key
redis·后端
掘金者阿豪33 分钟前
MySQL兼容性实践:从SQL语法适配到业务系统平滑迁移
后端
超低空1 小时前
一文说清LRU算法
后端·算法·架构
前端小万1 小时前
思考,行动,复盘|2026
前端·后端·面试
Sailing2 小时前
🚀客户端都超时了,你的 Go 服务还在查库?Context 取消链路不打通,连接池迟早被打爆
后端·面试·go
拖孩2 小时前
# 我又用 AI 做了个小程序:24 天,记录我这辈子认识的人
前端·后端·微信小程序
Csvn2 小时前
Nginx rewrite 与 server_name:last/break 语义、多域名匹配与伪静态
后端·nginx
AAA修煤气灶刘哥3 小时前
32 GB 内存跑起 1800 亿参数模型,代价是什么?
人工智能·后端·架构
SimonKing3 小时前
零 OCR 依赖!Firecrawl 这个 Rust 库把 Word / PPT / Excel 全变成 Markdown
java·后端·程序员