本文分析的是 Java 8 中的
HashMap
。
静下心来…
底层数据结构
数组+链表 任然是做为其最初的底层结构,但在 Java 8 中新增了 红黑树,在某种情况下,又将会转化为 数组+红黑树。
存储的元素为 Node<K,V>
,它仍然为 Map.Entry<K,V>
:
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
// 省略了 get/set/equals 方法
当某部分节点由链表转换为红黑树时,节点将由普通节点变为树型节点:
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;
}
// 这里仅仅列出了成员,其涉及的方法比较多,可自行查阅源码
初始化
在调用构造函数时,仅仅初始化了 loadFactor
和 threshold
,threshold
用于判断表什么时候扩容,它的值等于 (loadFactor
* capacity
)。 loadFactor
则表示在超过了表大小的多少重新进行扩容。注意,这时候表尚未初始化。
在调用 put
方法时,表才初始化:
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 表是否需要初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 如果以hash值作为下标对应的数组元素不存在,则直接插入新的元素
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 此次为插入重复元素操作
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) {
// 找到尾结点,插入
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 判断是否达到树化阈值(8)
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 1.树化该箱(当前数组元素)
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;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 回调方法
afterNodeAccess(e);
return oldValue;
}
}
// 并发计数加 1
++modCount;
// 2. 是否需要扩容
if (++size > threshold)
resize();
// 回调方法
afterNodeInsertion(evict);
return null;
}
第一步所指的树化该箱(当前数组元素)不太好理解,其实指的是将数组元素的链表结构,调整为树结构(链表长度为 9)。
平常所说多为 链表长度为 8 时,开始转换为红黑树,这应该是指新节点插入前;但从源码来看,是先插入新的节点,后尝试树型化,所以描述为 “链表长度为 9 ,开始转换为红黑树 ” ,或许更准确。
再来看具体的树型化方法:
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 1.如果表大小小于 64 , 则进行扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
// 后续涉及扩容时,再具体分析
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
// 替换链表中的所有节点为树节点
do {
// 将普通节点替换为树节点
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
// 真正树型化,后续涉及红黑树时,再具体分析
hd.treeify(tab);
}
}
如 1 所述,当表大小小于 64 时,并不触发树型化该箱(指当前链表),也就是说,链表长度大于 8 时,底层并不一定会转换为红黑树;表的大小必须要达到要求的最小树型化值,即 64。
存取操作
上文对于 HashMap
的存其实分析的已经差不多了,下面看看它是如何取的:
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
不知道,各位有没有发现,这里的 key 并没有使用泛型,而直接使用的 Object ,反正以前,我是没有注意到。而且 HashMap
是允许 key 为 null 的,所以这里未做边界检查,当 key 为 null 时,hash 为 0。
如果该方法返回 null,那么对于允许 value 值为 null 的 Map ,并不能判断是否该 key 没有对应的值,或者是该 key 显示的映射了 null,但可以结合
containsKey
方法来做区分。
下面来看具体的 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 &&
(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)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 循环遍历链表,查找节点
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
上面的逻辑比较简单,但值得一提的是,每次都会先比较第一个节点,不论底层是链表,还是红黑树。这里再分析下为什么 key 并没有使用泛型,底层其实并不关心这个 key 具体是什么对象,因为它只需要调用它的 equals 方法,知道 key 是否相等。但是,我仍然觉得,这可能使我无法在编译期更早地发现错误,个人拙见。
扩容
初始化以及扩容,都在 resize 方法中进行的。在进行扩容时,每个箱(数组元素所涉及的链表或者红黑树)中的元素必须保持相同的索引,或者以 2 的 幂(原表的大小)在新表中偏移。
计算新数组索引时,原始索引计算方式 hash & (cap - 1 ), 新的索引计算方式是 hash & (2 * cap - 1), 这里转换一下,其实新的索引要么等于原数组中的索引大小,要么等于 原数组中的索引大小加原数组cap。
例如,原始 cap 为 16(2 的 4 次幂,这里的 4 计为 n),新的 cap 则为 32(2 的 n+1 次幂):
- 旧索引:hash & 001111, 其实是保留 hash 的低四位,即保留低 n 位
- 新索引:hash & 011111,其实是保留 hash 的低五位,即保留低 n+1 位
可以看出新索引和旧索引的差别取决于第 n+1 位(转换为十进制则为原 cap 大小)的值,如果该位为 1,则偏移,为 0 则为原索引,所以只需要计算该位便能确定是否需要偏移了,则也是为什么下文代码中采用 (e.hash & oldCap) == 0
的判断。
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) {
// 达到所能承载的最大值 2的30次方,直接返回,不再扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 2倍扩容,2倍阈值(仅当扩容后的容量小于最大值时)
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
newCap = oldThr;
// 初始化
else { // zero initial threshold signifies using defaults
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;
// 数组元素为单个节点,则不改变hash值,直接插入新表
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 1. 数组元素为红黑树,涉及红黑树操作,后续补充
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;
}
// 原数组中的索引大小加原数组cap 时,构造链表
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;
}
关于如何对红黑树进行迁移,则留在后续了。这里需要注意的是对于链表的迁移,划分了两种情况,定义了两个链表的头尾节点。因为针对不同的 hash 值,采用不同的迁移策略。
红黑树以及迭代器实现
红黑树和迭代器,我打算另起博文来写,这样会写的更透彻点。
推荐博文
我与风来
认认真真学习,做思想的产出者,而不是文字的搬运工
错误之处,还望指出