引言
笔者经历过不下50场面试，HashMap 底层原理这道题即使没有被问过30遍也至少被问了20遍了，那么为什么一道已经被问烂的题目仍然受到广大面试官的青睐呢？其实原因无非两点：
- HashMap 在项目中会经常使用到，在很多业务逻辑中都有他的影子；
- HashMap 的底层原理涉及了很多数据结构相关的知识点，以它为起点可以牵引出很多连环问题
本文就带着大家去看一遍HashMap的源码，主要是看 put、get 以及 resize 这三个函数。
HashMap源码分析
put()
点开 put() 的源码，可以看到它的一个顶层方法 putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict), 它有5个参数：
- hash: key的哈希值
- key: 键
- value: 值
- onlyIfAbsent：如果当前存在一个值是否替换，false为替换，true为不替换
- evict【不重要】：是否为创建模式，如果为false则表示处于创建模式
上面五个参数需要重点关注前四个参数，因为它们影响着整个 putVal() 方法的逻辑。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
在讲完顶层入口以后，相信同学们一定对 hash(key) 这个方法产生了很大的好奇心，顾名思义，这个方法一定是用来计算hash值的，但 HashMap 对其有何细节处理呢？
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
可以看到上述代码在判空后，进行了两步操作：
- 对 key 的哈希值进行了运算并保留结果 h；
- h 右移16位并与自身作异或运算
对于哈希值的具体计算方法这里就不关注了，需要注意的是后续的两次扰动操作。其实结合后面的代码就可以很轻松的理解：因为哈希桶扩容是慢慢变大的，绝大部分情况不需要很大的哈希桶，那么意味着高位的哈希值长时间得不到利用，使得后续计算下标的时候无法利用高位的数据，这一切都会导致 key的下标变得集中而不是均匀的分散在哈希桶各处。因此，HashMap 处理哈希冲突的第一步就是：利用两次扰动充分利用 key 的哈希值，使得后面计算 key 下标时分布更均匀，从而减少冲突。
再往后看 putVal() 的函数主体部分：
仔细观察会发现 HashMap 主要利用了拉链法来解决哈希冲突（但拉链法会遇到什么问题呢，这里留给大家思考，可以评论区发表意见）
哈希冲突的含义: 键(key)经过hash函数得到的结果作为地址去存放当前的键值对(key-value)(这个是hashmap的存值方式)，但是却发现该地址已经有人先来了，一山不容二虎，就会产生冲突，这个冲突就是hash冲突。
- 开放地址法
这种方法也称再散列法，其基本思想是：当关键字key的哈希地址p=H（key）出现冲突时，以p为基础，产生另一个哈希地址p1，如果p1仍然冲突，再以p为基础，产生另一个哈希地址p2，…，直到找出一个不冲突的哈希地址pi ，将相应元素存入其中。这种方法有一个通用的再散列函数形式：
Hi=（H（key）+di）% m i=1，2，…，n
其中H（key）为哈希函数，m 为表长，di称为增量序列。增量序列的取值方式不同，相应的再散列方式也不同。主要有以下三种：
- 线性探测再散列
这种方法的特点是：冲突发生时，顺序查看表中下一单元，直到找出一个空单元或查遍全表- 二次探测再散列
这种方法的特点是：冲突发生时，在表的左右进行跳跃式探测，比较灵活- 伪随机探测再散列
增量序列是一个伪随机数序列- 再哈希法
当哈希地址Hi=RH1（key）发生冲突时，再计算Hi=RH2（key）……，直到冲突不再产生。这种方法不易产生聚集，但增加了计算时间。- 链地址法
这种方法的基本思想是将所有哈希地址为i的元素构成一个称为同义词链的单链表，并将单链表的头指针存在哈希表的第i个单元中，因而查找、插入和删除主要在同义词链中进行。链地址法适用于经常进行插入和删除的情况。- 建立公共溢出区
这种方法的基本思想是：将哈希表分为基本表和溢出表两部分，凡是和基本表发生冲突的元素，一律填入溢出表。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 创建哈希桶 tab, 以及节点 p, 并初始化哈希桶长度 n 以及 key 下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 哈希桶为空或长度为0时进行初始化操作（调用扩容函数）
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 计算 key 对应的下标 i, 并判断该位置上的值是否为空
if ((p = tab[i = (n - 1) & hash]) == null)
// 若为空则创建新节点
tab[i] = newNode(hash, key, value, null);
else {
// 创建临时节点 e, 临时变量 k 保存 p 节点上的 key
Node<K,V> e; K k;
// 此处做了三步操作：
// 1. 判断 hash 值是否相等; 2. 判断 key 的地址是否相等; 3. 判断 key 的值是否相等
// 这样做的好处是排除了特殊情况，加快了 key 的平均对比效率
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 如果相等, 那么将临时节点赋值为 p, 后续进行覆盖
e = p;
else if (p instanceof TreeNode)
// 如果 p 节点是一个树节点, 直接进行树节点插入操作
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 如果 p 节点是一个链表节点, 那么遍历链表
for (int binCount = 0; ; ++binCount) {
// 如果链表中不存在值为 key 的节点, 那么直接尾插
if ((e = p.next) == null) {
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;
}
}
// 如果 e 不为空, 证明需要进行覆盖操作
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;
}
注释中已基本标明了该函数的细节部分，其实流程总结起来无非是以下几步：
- 判断哈希桶是否为空，若为空则进行初始化
- 计算下标, 判断当前位置是否为空
- 为空，则创建新节点
- 不为空
- 判断是否和当前位置节点的 key 值相等
- 相等则进行覆盖
- 不相等
- 若为树节点，直接利用红黑树方法进行节点插入
- 若为链表节点，则遍历链表
- 寻找到相等 key，覆盖
- 未寻找到，尾插，尾插后进行树化判断
- 判断是否和当前位置节点的 key 值相等
- 哈希桶计数, 超过阈值则扩容
以上就是整个 put() 流程，这也是 HashMap 最精华的部分，需要重点关注。
get()
get() 也是一个顶层入口，其逻辑和 put() 类似，都是先计算 key 的 hash 值，不过 get 主要是进行查
public V get(Object key) {
Node<K,V> e; // 临时节点
// 计算 hash 值, 然后调用 getNode 方法进行查操作
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
接着就来看主方法 getNode()：
final Node<K,V> getNode(int hash, Object key) {
// 创建哈希桶临时遍历 tab, 创建临时节点 first, 创建临时哈希桶长度 n, 临时键 k
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 如果哈希桶不为空且 key 对应下标节点不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 判断是否相等
if (first.hash == hash &&
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 查看是否还有 next 值
if ((e = first.next) != null) {
// 对树节点调用专用方法进行查操作
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 循环遍历链表查找是否存在相等的 key
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
// 无法查询到则返回 null
return null;
}
get() 的整体逻辑和 put() 十分类似，此处不再赘述，注释已将细节标明。
resize()
扩容也是 HashMap 的一大重点环节，因为在哈希表的使用根据不同场景需要用到不同大小的哈希桶，因此必须引入扩容机制，这样可以灵活的根据场景进行调节。
先来看看它的源码：
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
}
// 容量若为0则初始化容量
else if (oldThr > 0)
// 阈值大于0则将新容量设置为旧的阈值
newCap = oldThr;
else {
// 若阈值等于0则将新容量设定为默认初始化容量
newCap = DEFAULT_INITIAL_CAPACITY;
// 阈值同样按照容量 * 默认负载因子
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 若新阈值为0
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;
// 如果只有一个节点
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 {
// 设定链表头尾节点
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
// 遍历旧的链表
do {
next = e.next;
// 如果 hash 值和旧容量的按位与结果为0
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 如果 hash 值和旧容量的按位与结果不为0
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// lo链表放置在原始下标下
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// hi链表放置在新下标（原始下标+旧容量）下
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
// 扩容完毕，返回新哈希桶
return newTab;
}
不难发现，HashMap 的扩容不是简单的整体移动，而是进行了一次扰动操作（if ((e.hash & oldCap) == 0)），完成了再分配，这样可以利用扩容来均匀所有节点。
结语
到这里也就讲完了 HashMap 的重要方法，其实认真读下来发现这部分源码并不难理解，主要是哈希冲突解决的一种具体实现，对于理解拉链法有很好的作用。同学们切记不要死记硬背，笔者看到网上有很多 HashMap 的流程图，但那其实并不是 HashMap 的精华所在，我们需要去体会作者的编码思路，这样才能有更好的成长！
370
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
