一、HashMap 概述
HashMap 是 Java 集合框架中最重要且最常用的数据结构之一，它提供了基于键值对(key-value)的高效存储和检索功能。作为 Map 接口的主要实现类，HashMap 在 Java 开发中扮演着至关重要的角色。
1.1 HashMap 的基本特性
- 基于哈希表实现：使用数组+链表+红黑树（JDK8+）的复合结构
- 非线程安全：多线程环境下需要外部同步或使用 ConcurrentHashMap
- 允许 null 键和 null 值：但只能有一个 null 键
- 不保证元素顺序：插入顺序和遍历顺序可能不一致
- 初始容量和负载因子：可配置的参数影响性能
1.2 HashMap 的类继承关系
java.lang.Object
↳ java.util.AbstractMap<K,V>
↳ java.util.HashMap<K,V>
HashMap 实现了 Map 接口，继承自 AbstractMap 类，同时实现了 Cloneable 和 Serializable 接口，支持克隆和序列化。
二、HashMap 的核心数据结构
2.1 JDK7 及以前的实现：数组+链表
在 JDK7 及以前版本中，HashMap 采用简单的数组加链表结构：
[数组索引] → Entry1 → Entry2 → Entry3 → null
每个数组元素是一个 Entry 链表的头节点，Entry 包含 key、value、hash 和 next 指针。
2.2 JDK8 及以后的优化：数组+链表+红黑树
JDK8 对 HashMap 进行了重大优化，当链表长度超过阈值(默认为8)时，会将链表转换为红黑树：
[数组索引] → TreeNode1 ↔ TreeNode2 ↔ TreeNode3
这种改进将最坏情况下的查找时间从 O(n) 降低到 O(log n)。
三、HashMap 的工作原理
3.1 存储原理（put 操作）
以下是 HashMap 存储元素的详细流程：
graph TD
A[开始put操作] --> B[计算key的hash值]
B --> C[计算数组下标index]
C --> D{当前位置是否为空?}
D -->|是| E[直接创建新节点插入]
D -->|否| F{key是否已存在?}
F -->|是| G[替换旧值]
F -->|否| H{是否是树节点?}
H -->|是| I[红黑树插入]
H -->|否| J[链表遍历插入]
J --> K{链表长度≥8?}
K -->|是| L[转换为红黑树]
K -->|否| M[继续链表插入]
E & G & I & L & M --> N[检查是否需要扩容]
N --> O[结束]
3.1.1 哈希计算
HashMap 首先计算键的哈希值：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这个方法称为"扰动函数"，通过将高16位与低16位异或，减少哈希冲突。
3.1.2 确定数组下标
根据哈希值计算数组下标：
index = (n - 1) & hash // n是数组长度
3.1.3 处理哈希冲突
当不同键计算出相同的数组下标时，HashMap 采用链地址法解决冲突：
- 如果当前位置为空，直接插入
- 如果键已存在，替换对应的值
- 如果是树节点，执行红黑树插入
- 否则遍历链表，在末尾插入新节点
3.1.4 树化条件
当链表长度达到 TREEIFY_THRESHOLD(8) 且数组长度达到 MIN_TREEIFY_CAPACITY(64) 时，链表会转换为红黑树。
3.2 读取原理（get 操作）
读取操作的流程如下：
3.3 扩容机制
HashMap 的扩容是一个耗时的操作，需要重新计算所有元素的位置并迁移数据。
3.3.1 扩容条件
当元素数量超过阈值时触发扩容：
阈值 = 容量 × 负载因子(默认0.75)
3.3.2 扩容过程
- 创建新的数组（大小为原数组的2倍）
- 遍历旧数组中的每个元素
- 重新计算每个元素在新数组中的位置
- 将元素迁移到新数组
JDK8 优化了扩容过程，元素的新位置要么是原位置，要么是原位置+旧容量，无需重新计算hash。
四、核心源码分析
4.1 关键静态常量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认初始容量16
static final int MAXIMUM_CAPACITY = 1 << 30; // 最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认负载因子
static final int TREEIFY_THRESHOLD = 8; // 树化阈值
static final int UNTREEIFY_THRESHOLD = 6; // 链表化阈值
static final int MIN_TREEIFY_CAPACITY = 64; // 最小树化容量
4.2 Node 节点类
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; // 哈希值
final K key; // 键
V value; // 值
Node<K,V> next; // 下一个节点
// 构造方法和其他方法...
}
4.3 TreeNode 节点类
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; // 颜色属性
// 红黑树相关方法...
}
4.4 putVal 方法核心代码
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果表为空或长度为0，则扩容
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;
}
// 检查是否找到匹配的key
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 如果找到匹配的key，替换value
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;
}
五、性能分析与优化
5.1 时间复杂度
| 操作 | 平均情况 | 最坏情况(JDK7) | 最坏情况(JDK8+) |
|---|---|---|---|
| 插入 | O(1) | O(n) | O(log n) |
| 查找 | O(1) | O(n) | O(log n) |
| 删除 | O(1) | O(n) | O(log n) |
5.2 影响性能的因素
- 初始容量：过小会导致频繁扩容，过大会浪费内存
- 负载因子：权衡空间和时间利用率
- 哈希函数质量：决定元素分布是否均匀
- 键对象的 hashCode() 和 equals()：实现质量影响冲突率
5.3 优化建议
- 预估元素数量，设置合理的初始容量
- 对于已知的键集合，考虑自定义哈希函数
- 确保键对象实现了高质量的 hashCode() 和 equals()
- 在多线程环境下使用 ConcurrentHashMap 而非 HashMap
六、线程安全问题
6.1 HashMap 的非线程安全表现
- 死循环问题(JDK7)：多线程扩容可能导致链表成环
- 数据丢失：并发put可能导致元素覆盖
- size不准确：并发修改导致size计算错误
6.2 解决方案
- 使用
Collections.synchronizedMap包装 HashMap - 使用
ConcurrentHashMap（推荐） - 在外部进行同步控制
七、常见面试问题
-
HashMap 的工作原理是什么？
- 基于哈希表实现，使用链地址法解决冲突，JDK8后加入红黑树优化
-
HashMap 的扩容机制是怎样的？
- 当size超过threshold(容量×负载因子)时扩容为原来的2倍
-
为什么 HashMap 的容量总是2的幂次方？
- 方便使用位运算计算下标：(n-1)&hash 等价于 hash%n，但效率更高
-
HashMap 和 HashTable 的区别？
- HashMap非线程安全，允许null键值；HashTable线程安全，不允许null键值
-
JDK8 对 HashMap 做了哪些优化？
- 引入红黑树，优化哈希计算，改进扩容机制
八、总结
HashMap 是 Java 集合框架中一个高效且灵活的数据结构，理解其内部实现原理对于编写高质量的Java代码至关重要。从JDK7到JDK8，HashMap经历了显著的性能优化，特别是引入了红黑树结构来处理哈希冲突。在实际开发中，我们应该根据应用场景合理配置初始容量和负载因子，并注意其在多线程环境下的安全问题。
通过本文的深入分析，希望读者能够全面掌握HashMap的工作原理、实现细节和优化方法，从而能够在实际开发中更加得心应手地使用这一重要数据结构。
扫一扫
514
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
