Java HashMap 初步分析
说到 HashMap,我们想到的就是映射和散列。映射,形象化地说又叫键值对,一个键对应一个值,这种特性使它的应用非常广泛;散列,我的理解就是利用哈希码提高查找的速度,一个好的哈希策略应该能够尽可能地避免冲突(碰撞),又能够节约存储空间。当碰撞发生时,要采取什么策略,也是一个难题。
HashMap 是 Java 应用中最常用的类型之一,属于不可不学的基础知识...So,打开源码,看看它牛逼在哪里。
本文将从相关数据结构和操作两个方面分析。
数据结构
在 JDK 1.7 中 HashMap 的组成是数组 + 链表,而 JDK 1.8 新增了红黑树结构,当链表的长度大于 8 时会转换为红黑树,以提升元素的操作性能。
图示:
HashMap 用静态内部类 Node<K,V> 保存键值对,它包含四个字段:
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
// ...
}
注意区分:
- hash 字段是根据 key 计算得来的;
- Node 有自己的 hashCode 方法,返回
Objects.hashCode(key) ^ Objects.hashCode(value)
;
在进一步学习之前,我们先整理一下 HashMap 中规定的几个重要常量:
- 默认的初始化容量(DEFAULT_INITIAL_CAPACITY):16;
- 最大容量(MAXIMUM_CAPACITY):
1 << 30
即 2^30; - 默认的负载因子(DEFAULT_LOAD_FACTOR):0.75;
- 从链表变为红黑树的阈值(TREEIFY_THRESHOLD):8;
- 从链表变为红黑树要求的最小容量(MIN_TREEIFY_CAPACITY):64;
这里有 3 个关键概念:容量、负载因子、树化(treeify)阈值。
1. 容量
容量指的是 HashMap 内部的Node<K,V>[]
数组的大小,默认的初始化容量是 16,当空间不足时会自动扩容为原来的 2 倍,扩容后的大小始终是 2 的 n 次幂,并且要求 n <= 30。 可以在构造方法中指定初始化容量,记住必须是 2 的幂。
2. 装填因子
装填因子指明了什么时候对数组进行扩容,默认的装填因子是 0.75,也就意味着 Node 的数量超过容量的 75% 时就会进行扩容。“装填”一词,如果我们把每个数组元素看作一个桶(bucket),是不是就很形象?也可以在构造方法中自定义装填因子,不过一般不这么做,因为 0.75 被证明是一个合理的折中选择。
HashMap 有一个 int 类型的字段 threshold,它是扩容的临界值,初始化的计算公式是容量 * 装填因子
,并且在每一次数组扩容后都会跟着扩大为原来的 2 倍。如果数组的容量已经达到最大值,threshold 取值为Integer.Max_VALUE
。
3. 树化阈值
一个“桶”从链表转变为红黑树的阈值是 8。
源码注释:树节点的大小大约是普通节点的两倍,所以我们只在桶包含足够的节点时才使用树节点。当它们变得太小(由于删除或调整大小)时,就会被转换回普通的链表。在使用分布良好的哈希码时,很少需要使用树结构。
为什么是 8 呢?理想情况下,哈希码是随机出现的,选择装填因子为 0.75,则桶中节点的个数遵循泊松分布:
$$P(x)=\frac{e{-1/2}·x{1/2}}{x!}$$
节点个数和概率的对照表:
* 0: 0.60653066
* 1: 0.30326533
* 2: 0.07581633
* 3: 0.01263606
* 4: 0.00157952
* 5: 0.00015795
* 6: 0.00001316
* 7: 0.00000094
* 8: 0.00000006
* more: less than 1 in ten million
也就是说,在装填因子为 0.75,树化阈值为 8 的设计下,出现链表转红黑树的概率小于千万分之一。
链表转换成树还有一个最小容量限制,当容量小于 64 且某条链表长度大于 8 时,会进行扩容而不是 treeify。
操作
HashMap 有三个重要操作:
- 查询
- 新增
- 扩容
下面我们来看看这些操作涉及到哪些逻辑。
1. 查询
首先看get
方法的内部实现:
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
- 用
hash
方法对 key 生成散列值; - 调用
getNode
方法找到 Node,返回 value。
hash
策略如下:
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
当 key 是空值时,散列值是 0。不过后面的计算要怎么理解呢?举个栗子:
// 1) h: 11000110 11110010 00100110 11100011
// 2) h >>> 16: 00000000 00000000 11000110 11110010 // 逻辑右移
// 3) hash: 11000110 11110010 11100000 00010001
高 16 bit 不变,低 16 bit 与高 16 bit 进行了一次异或。
再看看索引的计算:
(n - 1) & hash // n为数组长度
用了与运算&
而不是取余%
,两者等价,但位运算效率更高。
假如长度是 16,则:
// 3) hash: 11000110 11110010 11100000 00010001
// 4) n - 1: 1111
// 5) index: 0001
索引为 1,hash 真正有效的只有低 4 bit。
源码注释:由于数组长度是 2 的幂,因此仅在较低位上变化的散列集总是会发生冲突。因此,我们应用了一个转换,将更高位的影响通过异或向下传播,在速度、效用和质量之间进行权衡。
下面的重点是getNode
方法:
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
// 根据hash计算索引
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
// 树结构则调用getTreeNode
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
// 先比较hash再调用equals
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
流程图:
思路总结:
- 根据 hash 计算 bucket 索引;
- bucket 里的第一个节点,直接命中;
- 如果有冲突,则通过
key.equals(k)
查找节点; - 如果是树结构,O(logN);如果是链表,O(N)。
2. 新增
put
方法的实现:
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
实际用的是putVal
:
/**
* @param hash key 的 hash
* @param key
* @param value
* @param onlyIfAbsent 如果为 true,则不改变已经存在的 value
* @param evict 如果为 true,表示 table 是创建状态
* @return 旧的 value,如果没有则为 null
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果哈希表为空则调用resize
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 如果 bucket 为空,则根据索引直接创建节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 如果 bucket 不为空,开始查找
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 存在旧值
e = p;
// 如果是树结构,调用putTreeVal
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) {
// 在链表尾插入,JDK 1.8 的优化部分
p.next = newNode(hash, key, value, null);
// 判断是否需要转变为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
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;
// size加1,如果超过threshold则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
流程图:
思路总结:
- 根据 hash 计算 bucket 索引;
- 如果 bucket 为空则直接创建;
- 如果碰撞了,对链表或树进行插入;
- 如果插入后链表过长,就转换成红黑树;
- 如果节点已经存在就替换旧值;
- 如果 size > threshold 就要扩容。
3. 扩容
扩容有两种情况:
- 初始化;
- 表大小扩为原来 2 倍。
如果哈希表(也就是内部数组)为空,则按照指定的初始容量创建一张表。否则每个元素要么保持相同的索引,要么偏移与旧表长度相同的距离。
final Node<K,V>[] resize() {
// 扩容前的数组
Node<K,V>[] oldTab = table;
// 扩容前的数组大小和阈值
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
// 预定义新数组的大小和阈值
int newCap, newThr = 0;
// 表存在,决定是否扩容
if (oldCap > 0) {
// 超过最大值则不扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 扩容为当前的 2 倍,但不能超过最大值
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 表不存在,初始化
else if (oldThr > 0) // 初始化容量的值存放在字段 threshold 中
newCap = oldThr;
else { // threshold 等于 0 意味着使用默认的初始化容量
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算新的阈值
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 开始扩容
table = newTab;
// 将原数据(如果有)复制到新的表中
if (oldTab != null) {
// 遍历旧表
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 如果 bucket 只有一个节点,则直接复制
if (e.next == null)
// 重新计算了索引
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
// 红黑树相关操作
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 链表,保持原有顺序
// JDK 1.8 扩容优化部分
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
// 遍历链表
do {
next = e.next;
// 索引不变(思考:为什么不是 e.hash & (newCap-1) == j ?)
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
// 在链表尾插入
loTail.next = e;
loTail = e;
}
// 索引偏移
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
// 偏移长度是 oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
判断是否保留原来的索引时,为什么用(e.hash & oldCap) == 0
?
同一条链表中的节点 hash 值都是相同的,如果hash & (oldCap-1)
等于hash & (newCap-1)
,意味着保留原来索引。不妨假设原先的数组长度是 32,扩容后的长度就是 64,讨论一下 hash 的两种情况:
1.假设 hash 为 150(0x1001 0110)
// hash : 1001 0110
// hash & (0x011111) : 0001 0110 有效位有 5 个
// hash & (0x111111) : 0001 0110 有效位有 6 个
// 结论:保留原索引
// oldCap : 0010 0000
// hash & oldCap : 0000 0000 == 0
2.假设 hash 为 182(0x1011 0110),改动了一个位
// hash : 1011 0110
// hash & (0x011111) : 0001 0110 有效位有 5 个
// hash & (0x111111) : 0011 0110 有效位有 6 个
// 结论:索引需要偏移
// oldCap : 0010 0000
// hash & oldCap : 0010 0000 != 0
也就是在“扩容 2 倍,始终是 2 的幂”的约束下,e.hash & oldCap
的运算结果代表新增有效位是否为 1,如果是,就意味着hash & (oldCap-1)
不等于hash & (newCap-1)
。两个判断条件是等价的,设计者选择了效率更高的判断方式。
PS:最后,有一个问题,为什么 JDK 1.8 要特意改为链表尾正序插入?
原因是 JDK 1.7 中使用的首部倒序插入存在死循环问题,由于 HashMap 是线程不安全的,多个线程同时进行新增操作并触发扩容时,可能会使链表产生循环引用,这个问题的详细讨论可以参考:
HashMap 在高并发下引起的死循环,杰哥长得帅,简书
END
如有错误,欢迎指正。