注：源码系列文章主要是对某付费专栏的总结记录。如有侵权，请联系删除。
整体架构
HashMap 底层的数据结构主要是：数组 + 链表 + 红黑树。其中当链表的长度大于 8 时，链表就会转化成红黑树，当红黑树的大小小于 6 时，红黑树会转化成链表，整体的数据结构如下：
图中左边竖着的是 HashMap 的数组结构 table，数组的元素可能是单个 Node，也可能是个链表，也可能是个红黑树，比如数组下标索引为 1 的位置就是一个链表，下标索引为 8 的位置对应的就是红黑树，具体细节下文继续。
1.1 类注释
从 HashMap 的类注释中，我们可以得到如下信息：
- 允许 null 值（作为键或值），不同于 HashTable，是线程不安全的；
load factor（影响因子）默认值是0.75，是均衡了时间和空间损耗算出来的值，较高的值会减少空间开销（扩容减少，数组大小增长速度变慢），但增加了查找成本（hash 冲突增加，链表长度变长），不扩容的条件：数组容量 > 需要的数组大小 / load factor；- 如果有很多数据需要存储到 HashMap 中，建议 HashMap 的容量一开始就设置成足够的大小，这样可以防止其过程中不断的扩容，影响性能；
- HashMap 是非线程安全的，我们可以自己在外部加锁，或者通过
Collections#synchronizedMap来实现线程安全，Collections#synchronizedMap的实现是在每个方法上都加上了synchronized锁； - 在迭代过程中，如果 HashMap 的结构被修改，会快速失败。
1.2 常见属性
// 初始容量默认值为 16，必须是 2 的幂次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量默认值，必须是 2 的幂次方并且小于等于 1 << 30
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;
// 存放数据的数组
transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
// HashMap 的实际大小
transient int size;
// 记录迭代过程中 HashMap 结构是否发生变化，如果有变化，迭代会 fail-fast
transient int modCount;
// 扩容阈值，有两种情况：
// 初始化时指定了数组大小的话，则通过 tableForSize 方法计算，计算的结果为大于指定大小并且最接近该值的 2 的幂次方的值，数组的大小为 2 的幂次方
// 如果是通过 resize 方法进行扩容，大小 = 数组容量 * 0.75
int threshold;
// 自定义装载因子
// 空参构造器时，赋值为默认的负载因子 0.75
final float loadFactor;
// 链表的节点
static class Node<K,V> implements Map.Entry<K,V> {}
// 红黑树的节点
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {}
1.3 构造函数
1.3.1 无参构造器
public HashMap() {
// 指定装载因子为默认装载因子 0.75f
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
1.3.2 指定初始容量构造器
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// 赋值装载因子
this.loadFactor = loadFactor;
// 根据传入的容量大小计算最终容量大小。计算出来的该值大于传入的值，并且是最接近传入值的2次幂
// 如传入 25，计算出来的大于 25 并且是最接近 25 的 2 幂次方的值为 32
this.threshold = tableSizeFor(initialCapacity);
}
2 新增
新增源码流程图：
源码分析：
// hash: 通过 hash 算法计算出来的值
// onlyIfAbsent: false 表示即使 key 已经存在了，仍然会用新值覆盖原来的值，默认为 false
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// tab 表示数组，n 表示数组的长度，i 表示数组索引下标，p 为 i 下标位置的 Node 值
Node<K,V>[] tab; Node<K,V> p; 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 和值都相等，则直接把当前下标位置的 Node 赋值给临时变量
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 是链表的尾节点，则直接将新节点放到链表的尾部
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 = 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;
}
新增的流程上面已经表示很清楚了，接下来看看链表和红黑树的新增。
2.1 链表的新增
链表的新增比较简单，就是把当前节点追加到链表的尾部，和 LinkedList 的追加实现一样。
当链表长度大于等于 8 时，此时链表就会转化为红黑树，转化的方法是 treeifyBin，此方法有一个判断，当链表长度大于等于 8，并且整个数组大小大于 64 时，才会转换为红黑树，当数组大小小于 64 时，只会触发扩容，不会转化为红黑树。
可能面试的时候，有人问你为什么是 8，这个答案在源码注释中有说，翻译大概如下：
链表查询的时间复杂度是 O(n)，红黑树的查询复杂度是 O(log(n))。在链表数据不多的时候，使用链表进行遍历也比较快，只有当链表数据比较多的时候，才会转化为红黑树，但红黑树需要占用的空间是链表的两倍，拷贝到转化时间和空闲损耗，所以我们需要定义出转化的边界值。
在考虑设计 8 这个值时，参考了泊松分布概率函数，由泊松分布中得出结论，链表各个长度的命中概率为：
* 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
意思是，当链表的长度是 8 的时候，出现的概率是 0.00000006，不到千万分之一，所以说正常情况下，链表的长度不可能到达 8，而一旦达到 8 时，肯定是 hash 算法出了问题，所以在这种情况下，为了让 HashMap 仍然有比较高的查询性能，所以让链表转化为红黑树，我们正常些代码，使用 HashMap 时，几乎不会碰到链表转化为红黑树的情况，毕竟概率只有千万分之一。
2.2 红黑树的新增
略。
3 扩容
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
// 得到数组旧的容量大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 得到当前的负载因子
int oldThr = threshold;
int newCap, newThr = 0;
// 如果数组旧的容量大小大于0，则不是初始化扩容
if (oldCap > 0) {
// 如果已经达到了最大容量，就不再继续扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 扩容为旧容量大小的 2 倍
// 判断如果2倍扩容后的值小于最大容量限制，并且旧的容量大于等于默认初始化容量16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
// 能进入到这里，说明 oldCap = 0, 说明是指定容量初始化，此时扩容的大小就应该是 oldThr
// 且这个值必须是大于指定容量，并且最接近该值的 2 的幂次方(参考:1.3.2 指定初始容量构造器)
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 进入到这里，说明是使用无参构造器初始化，此时扩容的大小是默认大小 16
newCap = DEFAULT_INITIAL_CAPACITY;
// 下次扩容的阈值为 0.75 * 16 = 12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算扩容阈值，上面的判断中步骤 2 未设置该值
if (newThr == 0) {
// 计算下次扩容阈值
float ft = (float)newCap * loadFactor;
// 如果新的容量小于最大容量限制并且，下次扩容阈值小于最大容量限制时，赋值新的扩容阈值为计算出的值 ft, 否则为 Integer 的最大值
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) {
// help GC
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 { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
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;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
4 查找
HashMap 的查找分为以下三步：
- 根据 hash 算法定位数组的索引位置，equals 判断当前索引处节点是否是我们需要寻找的 key，是的话直接返回，不是的话继续往下；
- 判断当前节点有无 next 节点，有的话判断是链表类型，还是红黑树类型；
- 分别走链表和红黑树不同类型的查找方法。
源码如下：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 只有当数组不为空，并且数组长度大于0，并且根据当前查找key的hash得到的节点不为null才进入查找
if ((tab = table) != null && (n = tab.length) > 0 &&
(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;
// 如果当前节点的下一个节点 next 不为空则继续
if ((e = first.next) != null) {
// 判断当前节点是红黑树则走红黑树查找
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 判断当前节点是链表
// 采用自旋方式从链表中查找 key，e 初始化链表的头节点 first 的下一个节点 next
do {
// 如果当前节点 hash 等于 key 的 hash，并且 equals 相等，则当前节点就是我们要找的节点
// 当 hash 冲突时，同一个 hash 值上是一个链表的时候，我们通过 equals 方法来比较 key 是否相等的
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
// 否则，把当前节点的下一个节点拿出来继续寻找
} while ((e = e.next) != null);
}
}
return null;
}
红黑树的查找：略。
总结
HashMap 的内容虽然比较多，但大多数 API 都只是针对数组 + 链表 + 红黑树这种数据结构进行封装而已。
------------------------------------- END -------------------------------------
3970
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
