HashMap 源码解析
HashMap 源码很长，面试的问题也非常多，但这些面试问题，基本都是从源码中衍生出来的， 所以我们只需要弄清楚其底层实现原理，回答这些问题就会游刃有余。
整体架构
JDK1.8 中 HashMap 底层的数据结构是： 数组 + 链表 + 红黑树。当链表的长度大于等于 8 时，链表会转换成红黑树，当红黑树的大小小于等于 6 时，红黑树会退化为链表，整体的数据结构如下：
图中竖这的是 HashMap 的数组结构，数组的元素可能是单个 Node，也可能是个链表或红黑树。比如数组下标为 2 的位置就是一个链表，下标索引为 9 的位置对应的就是红黑树。
类注释
从 HashMap 的类注释中，我们可以得到如下信息：
- key 和 value 允许 null 值
- 不同于 HashTable ，是线程不安全的。我们可以自己在外部加锁，或者通过
Collections#synchronizedMap来实现线程安全，Collections#synchronizedMap的实现是在每个方法上加上了 synchronized 锁； load factor（负载因子）默认值是 0.75，是均衡了时间和空间损耗算出来的值，较高的值会减少空间开销（扩容减少，数组大小增长速度变慢），但增加了查找成本（hash 冲突增加，链表长度变长），扩容的条件 数组容量 < 需要的大小 / load factor- 如果有很多数据需要存储到 HashMap 中，建议 HashMap 的容量一开始就设置成足够的大小，防止在其过程中不断的扩容，影响性能
- 在迭代过程中，如果 HashMap 的结构被修改，会快速失败
常见属性
// 初始容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 负载因子默认值
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 桶上的链表长度大于等于8时，链表转换成红黑树
static final int TREEIFY_THRESHOLD = 8;
// 桶上的红黑树大小小于等于6时，红黑树退化成链表
static final int UNTREEIFY_THRESHOLD = 6;
// 当数组容量大于 64 时，链表才会转化成红黑树
static final int MIN_TREEIFY_CAPACITY = 64;
// 记录迭代过程中 HashMap 结构是否发生变化，如果有变化，迭代时会 fail-fast
transient int modCount;
// HashMap 的实际大小，可能不准(因为当你拿到这个值的时候，可能又发生了变化)
transient int size;
//存放数据的数组
transient Node<K,V>[] table;
// 扩容的门槛，有两种情况
// 如果初始化时，给定数组大小的话，通过 tableSizeFor 方法计算，数组大小永远接近于 2 的幂次方，比如你给定初始化大小 19，实际上初始化大小为 32，为 2 的 5 次方。
// 如果是通过 resize 方法进行扩容，大小 = 数组容量 * 0.75
int threshold;
// 链表的节点 单向链表
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
// 红黑树的节点
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
}
新增
新增 key-value 的大概步骤如下：
- 空数组有无初始化，没有的话初始化
- 通过 key 的 hash 找到数组的下标，判断是否 hash 冲突
- 冲突：判断链表或红黑树，新增节点或赋值覆盖
- 不冲突：把 key-value 放入数组中
- 判断是否需要扩容，需要则扩容
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// 计算hash值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
* Implements Map.put and related methods.
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param false 表示即使 key 已经存在了，仍然会用新值覆盖原来的值，默认为 false
* @param evict if false, the table is in creation mode.
* @return 返回被替换的旧值，如果新增返回null
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab;
// p为 i 下标位置的 Node 值
Node<K,V> p;
// n表示数组的长度，i为数组索引下标
int n, i;
// 如果数组为空，使用resize()方法初始化
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);
// 当前索引有值的处理情况，即hash冲突了
else {
// 当前节点临时变量e
Node<K,V> e; K k;
// 如果key的hash值和value值都相等，直接把原有的值存到临时变量e
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) {
// e = p.next 表示从头开始，遍历链表
// p.next == null 表明 p 是链表的尾节点
if ((e = p.next) == null) {
// 把新节点放到链表的尾部
p.next = newNode(hash, key, value, null);
// 当链表的长度大于等于8时，尝试链表转换成红黑树
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 在遍历过程中，一直往后移动。
p = e;
}
}
// 说明新节点的新增位置已经找到了
if (e != null) { // existing mapping for key
V oldValue = e.value;
// 当 onlyIfAbsent 为 false 时，才会覆盖值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
// 返回老值
return oldValue;
}
}
// 记录 HashMap 的数据结构发生了变化
++modCount;
// 如果 HashMap 的实际大小大于扩容的门槛，开始扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
链表新增的细节
链表的新增比较简单，就是把当前节点追加到链表的尾部，和 LinkedList 的追加实现是一样的。
当链表长度大于等于 8 时，链表会尝试转化成红黑树。当链表长度大于等于 8 ，但是整个数组小于 64 时，只会触发扩容，不会转换成红黑树。
红黑树新增节点
-
首先判断新增的节点在红黑树上是不是已经存在，判断手段有如下两种：
-
如果节点没有实现 Comparable 接口，使用 equals 进行判断
-
如果节点自己实现了 Comparable 接口，使用 compareTo 进行判断
-
-
-
新增的节点如果已经在红黑树上，直接返回；
-
不在的话，判断新增节点是在当前节点的左边还是右边，左边值小，右边值大；
-
-
自旋递归 1 和 2 步，直到当前节点的左边或者右边的节点为空时，停止自旋，当前节点即为我们新增节点的父节点；
-
把新增节点放到当前节点的左边或右边为空的地方，并于当前节点建立父子节点关系；
-
进行着色和旋转，结束。
//入参 h：key 的hash值
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab, int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
//找到根节点
TreeNode<K,V> root = (parent != null) ? root() : this;
//自旋
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk;
// p hash 值大于 h，说明 p 在 h 的右边
if ((ph = p.hash) > h)
dir = -1;
// p hash 值小于 h，说明 p 在 h 的左边
else if (ph < h)
dir = 1;
//要放进去key在当前树中已经存在了(equals来判断)
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
//自己实现的Comparable的话，不能用hashcode比较了，需要用compareTo
else if ((kc == null &&
//得到key的Class类型，如果key没有实现Comparable就是null
(kc = comparableClassFor(k)) == null) ||
//当前节点pk和入参k不等
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
//找到和当前hashcode值相近的节点(当前节点的左右子节点其中一个为空即可)
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
//生成新的节点
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
//把新节点放在当前子节点为空的位置上
if (dir <= 0)
xp.left = x;
else
xp.right = x;
//当前节点和新节点建立父子，前后关系
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
//balanceInsertion 对红黑树进行着色或旋转，以达到更多的查找效率，着色或旋转的几种场景如下
//着色：新节点总是为红色；如果新节点的父亲是黑色，则不需要重新着色；如果父亲是红色，那么必须通过重新着色或者旋转的方法，再次达到红黑树的5个约束条件
//旋转： 父亲是红色，叔叔是黑色时，进行旋转
//如果当前节点是父亲的右节点，则进行左旋
//如果当前节点是父亲的左节点，则进行右旋
//moveRootToFront 方法是把算出来的root放到根节点上
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
红黑树的新增，要求大家对红黑树的数据结构有一定的了解。面试的时候，一般只会问到新增节点到红黑树上大概是什么样的一个过程，着色和旋转的细节不会问，因为很难说清楚，但我们要清楚着色指的是给红黑树的节点着上红色或黑色，旋转是为了让红黑树更加平衡，提高查询的效率，总的来说都是为了满足红黑树的 5 个原则：
- 节点是红色或黑色
- 根是黑色
- 所有叶子都是黑色
- 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点
- 从每个叶子到根的所有路径上不能有两个连续的红色节点
查找
HashMap 的查找主要分为以下三步：
-
根据
(数组长度 - 1) & hash定位数组索引的位置，判断当前节点是否是我们需要寻找的 key，是的话直接返回，不是的话往下。 -
判断当前节点有无 next 节点，有的话判断是链表类型，还是红黑树类型。
-
分别走链表和红黑树不同类型的查找方法。
链表查找的代码是：
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab;
// first为指定key在数组中的元素的第一个节点
Node<K,V> first, e;
int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
// 定位到数组中的元素
(first = tab[(n - 1) & hash]) != null) {
// 如果元素的hash和key值都符合我们要查找的值，直接返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// first不止一个元素
if ((e = first.next) != null) {
// 红黑树
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 链表 用自旋方式从链表中查找 key，e 初始为为链表的头节点
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
红黑树查找的代码很多，我们大概说下思路，实际步骤比较复杂：
- 从根节点递归查找；
- 根据 hashcode，比较查找节点，左边节点，右边节点之间的大小，根本红黑树左小右大的特性进行判断；
- 判断查找节点在第 2 步有无定位节点位置，有的话返回，没有的话重复 2，3 两步；
- 一直自旋到定位到节点位置为止。
如果红黑树比较平衡的话，每次查找的次数就是树的深度。
302
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
