HashMap 底层原理全景解析：从结构到机制的深度拆解

最新推荐文章于 2026-08-14 12:15:53 发布

原创最新推荐文章于 2026-08-14 12:15:53 发布 · 1.7k 阅读

11 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

java技术深入浅出

HashMap 底层原理全景解析：从结构到机制的深度拆解

一、HashMap 核心定义与核心特性

HashMap 是 Java 集合框架 java.util 包下的核心实现类，基于 Map 接口设计，专门用于存储 键值对（Key-Value） 数据。其核心特性决定了它的应用场景与使用边界：

无序存储：JDK 8 前完全不保证插入顺序，JDK 8 后因红黑树与链表优化，会尽量保留插入特征，但不做官方承诺；
键唯一值可重复：Key 不允许重复（重复插入会覆盖原有 Value），Value 可多个重复，且支持 Key 和 Value 为 null（Key 仅允许一个 null，Value 无限制）；
非线程安全：多线程并发操作可能导致数据覆盖、链表成环（JDK 7）等问题，线程安全场景需使用 ConcurrentHashMap；
高性能：理想情况下存取效率为 O (1)，通过哈希算法、扩容机制与红黑树优化，平衡了存储效率与查询速度。

二、底层存储结构：从 JDK 7 到 JDK 8 的演进

HashMap 的底层结构是其性能的核心支撑，JDK 7 与 JDK 8 经历了重大优化，核心架构为 数组 + 链表 + 红黑树（JDK 8 新增）。

1. JDK 7 结构：数组 + 链表

数组（哈希桶 /table）：核心存储容器，数组元素为 Entry 节点，包含 key、value、hash（哈希值）、next（链表指针）四个属性；
链表（解决哈希冲突）：当不同 Key 计算出相同数组下标时（哈希冲突），通过链表将这些节点串联，采用 头插法 插入节点；
缺陷：链表长度随数据量增长而变长，查询时间复杂度退化至 O (n)，且头插法在多线程扩容时易导致链表成环，引发死循环。

2. JDK 8 结构：数组 + 链表 + 红黑树

为解决 JDK 7 链表查询效率低的问题，JDK 8 引入红黑树优化，形成 “三段式” 结构：

数组：仍为核心存储载体，节点类型改为 Node（与 Entry 功能一致，命名优化）；
链表：哈希冲突时先以链表存储，采用 尾插法 插入（避免多线程成环问题），链表长度阈值默认 8；
红黑树：当链表长度 ≥ 8 且数组长度 ≥ 64 时，链表自动转为红黑树（查询时间复杂度优化至 O (logn)）；当红黑树节点数 ≤ 6 时，自动转回链表（减少红黑树维护成本）；
核心优化点：结构升级后，最坏查询效率从 O (n) 提升至 O (logn)，同时修复了多线程扩容的死循环隐患。

三、核心机制深度解析：哈希计算与扩容

HashMap 的高性能依赖两大核心机制：哈希计算（确定元素存储位置） 与 扩容机制（动态调整存储容量），二者的设计直接决定了哈希分布均匀性与读写效率。

1. 哈希计算：从 Key 到数组下标的完整链路

哈希计算的核心目标是：将任意 Key 映射到数组的唯一下标，同时保证分布均匀、计算高效。完整流程为：Key → hashCode() → 扰动函数 → (length-1) & hash → 数组下标。

（1）第一步：获取 Key 的 hashCode ()

hashCode() 是 Object 类的原生方法，返回 32 位 int 型整数，用于标识对象的 “哈希特征”。核心规则：

相等的对象（equals() 为 true）必须返回相同的 hashCode；
不相等的对象可能返回相同的 hashCode（哈希碰撞的根源）；
示例："abc".hashCode() = 96354，"abd".hashCode() = 96355。

（2）第二步：扰动函数（hash () 方法）—— 融合高位信息

核心痛点：直接使用 hashCode 计算下标时，数组长度通常较小（默认 16），(length-1) & hash 仅能用到 hashCode 的低 4 位，高 28 位信息被忽略，导致 “高位不同、低位相同” 的 Key 产生哈希冲突。

扰动函数实现（JDK 8）：

static final int hash(Object key) {
	int h;
// 核心逻辑：高 16 位与低 16 位异或，融合高位特征
	return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

}

位运算解析：
- h >>> 16：将 32 位 hashCode 无符号右移 16 位，高 16 位移至低 16 位，高位补 0；
- ^（异或）：相同位为 0，不同位为 1，让高 16 位与低 16 位的特征融合，确保高位信息参与下标计算。
示例效果：

假设 hashCode 为 1100 1010 0011 1101 0101 1001 1010 0110，右移 16 位后为 0000 0000 0000 0000 1100 1010 0011 1101，异或后结果为 1100 1010 0011 1101 1001 0011 0001 1011，低位融合了高位差异。

（3）第三步：(length-1) & hash —— 映射下标

核心设计：数组长度 length 必须是 2 的幂（默认 16，扩容后翻倍），确保 length-1 的二进制为全 1（如 15 → 1111）。

优势 1：效率高于取模：(length-1) & hash 等价于 hash % length（仅当 length 为 2 的幂时），但位运算效率远高于取模（CPU 直接操作二进制）；
优势 2：分布更均匀：全 1 掩码让 hash 的低 n 位（n 为 length 的幂次）全部参与计算，无 “无效位”，减少下标集中；
示例：length=16（15→1111），hash=2763（二进制最后 4 位 1011），计算结果为 11，与 2763 % 16 = 11 完全一致。

2. 扩容机制（resize () 方法）—— 动态调整容量

当 HashMap 中元素数量超过 “容量 × 负载因子” 时，触发扩容，避免数组拥挤导致哈希冲突激增。

（1）核心参数

容量（capacity）：数组长度，默认初始值 16，最大容量 2^30，必须是 2 的幂；
负载因子（loadFactor）：默认 0.75，平衡 “空间利用率” 与 “冲突概率”（负载因子越大，空间利用率越高，但冲突概率越高）；
阈值（threshold）：扩容触发条件，threshold = capacity × loadFactor（默认 16×0.75=12）。

（2）扩容流程（JDK 8）

初始化判断：数组为空时，初始化容量为 16，阈值为 12；
容量上限判断：若当前容量已达 2^30，不再扩容，直接返回原数组；
扩容准备：新建数组，容量为原容量的 2 倍（保证仍是 2 的幂）；
元素迁移：将原数组的链表 / 红黑树节点迁移至新数组，JDK 8 优化迁移逻辑：

由于容量翻倍，新下标仅两种可能：原下标（hash 新增位为 0）或原下标 + 旧容量（hash 新增位为 1），无需重新计算哈希，仅需判断 1 位二进制；

更新状态：新数组替代原数组，更新容量与阈值（新阈值 = 新容量 × 负载因子）。

四、核心操作：put 与 get 方法流程

1. put 方法（存储元素）

public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
}

核心步骤：

计算 Key 的 hash 值（调用扰动函数）；
数组为空则触发扩容初始化；
根据 hash 计算下标，若该位置为空，直接新建节点插入；
若该位置已有节点：
- 节点 Key 与插入 Key 相同（hash + equals 均相等），覆盖 Value 并返回旧值；
- 节点为红黑树节点，调用红黑树插入方法；
- 节点为链表节点，尾插法插入链表，插入后判断链表长度是否 ≥8，若是则转为红黑树，元素数量 +1，若超过阈值，触发扩容。

2. get 方法（查询元素）

public V get(Object key) {
	return (e = getNode(hash(key), key)) == null ? null : e.value;
}

核心步骤：

计算 Key 的 hash 值；
数组为空或对应下标无节点，返回 null；
下标第一个节点为目标 Key（hash + equals 均相等），返回 Value；
否则遍历后续节点：
- 节点为红黑树，按红黑树查询逻辑查找；
- 节点为链表，遍历链表匹配 Key，找到则返回 Value，未找到返回 null。

五、实战注意事项与常见问题

1. Key 必须重写 hashCode () 与 equals ()

原因：hashCode() 决定 Key 的存储下标，equals() 决定 Key 是否真正相等；
反例：仅重写 equals 不重写 hashCode，会导致相同 Key 的 hashCode 不同，HashMap 认为是不同 Key，出现重复存储；
正确示例：

class User {

	private String id;
	
	@Override
	public int hashCode() { return Objects.hash(id); } // 以唯一标识计算 hash
	
	@Override
	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;
		User user = (User) o;
		return Objects.equals(id, user.id); // 以唯一标识判断相等
	}
}