说到 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
如有错误，欢迎指正。