HashMap 源码阅读

前言

　　之前读过一些类的源码，近来发现都忘了，再读一遍整理记录一下。这次读的是 JDK 11 的代码，贴上来的源码会去掉大部分的注释, 也会加上一些自己的理解。

Map 接口

　　

 

　　这里提一下 Map 接口与1.8相比 Map接口又新增了几个方法：
　　

• 这些方法都是包私有的static方法；

• of()

  方法分别返回包含 0 - 9 个键值对的不可修改的Map；

• ofEntries()

  方法返回包含从给定的

  entries

  总提取出来的键值对的不可修改的* Map（不会包含给定的

  entries

  ）；

• entry()

  方法返回包含键值对的不可修改的 Entry，不允许 null 作为 key 或 value；

• copyOf()

  返回一个不可修改的，包含给定 Map 的 entries 的 Map ，调用了

  ofEntries()

  方法.

数据结构

　　HashMap 是如何存储键值对的呢?　　

　　HashMap 有一个属性 table:

transient Node<K,V>[] table;

　　table 是一个 Node 的数组, 在首次使用和需要 resize 时进行初始化; 这个数组的长度始终是2的幂, 初始化时是0, 因此能够使用位运算来代替模运算.

　　HashMap的实现是装箱的(binned, bucketed), 一个 bucket 是 table 数组中的一个元素, 而 bucket 中的元素称为 bin .

　　来看一下 Node , 很显然是一个单向链表:

static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;

...
}

　　当然, 我们都知道 bucket 的结构是会在链表和红黑树之间相互转换的:

// 转换成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);

// 转换成链表结构
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);

　　注意在 

treeifyBin()

 方法中:

// table 为 null 或者 capacity 小于 MIN_TREEIFY_CAPACITY 会执行 resize() 而不是转换成树结构
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();

　　TreeNode 的结构和 TreeMap 相似, 并且实现了 tree 版本的一些方法:

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;

...
}

initialCapacity 和 loadFactor

　　先看一下 HashMap 的4个构造器，可以发现3个重要的 int ：threshold，initialCapacity 和 loadFactor ，其中 threshold 和 loadFactor 是 HashMap 的私有属性。

　　HashMap 的 javadoc 中有相关的解释：

• capacity，HashMap 的哈希表中桶的数量；
• initial capacity ，哈希表创建时桶的数量；
• load factor ，在 capacity 自动增加(

  resize()

  )之前，哈希表允许的填满程度；
• threshold，下一次执行

  resize()

  时 size 的值 (capacity * load factor)，如果表没有初始化，存放的是表的长度，为0时表的长度将会是 

  DEFAULT_INITIAL_CAPACITY

   。

　　注意: 构造器中的 initialCapacity 参数并不是 table 的实际长度, 而是期望达到的值, 实际值一般会大于等于给定的值. initialCapacity 会经过

tableSizeFor()

 方法, 得到一个不大于 MAXIMUM_CAPACITY 的足够大的2的幂, 来作为table的实际长度:

static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

　　loadFactor 的默认值是 0.75f ：

static final float DEFAULT_LOAD_FACTOR = 0.75f;

　　initialCapacity 的默认值是16：

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

　　capacity 的最大值是1073741824：

static final int MAXIMUM_CAPACITY = 1 << 30;

　　在 new 一个 HasMap 时，应该根据 mapping 数量尽量给出 initialCapacity , 减少表容量自增的次数 . 

putMapEntries()

 方法给出了一种计算 initialCapacity 的方法:

float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);

　　这段代码里的 t 就是 capacity .

hash() 方法

　　hash()

 是 HashMap 用来计算 key 的 hash 值的方法, 这个方法并不是直接返回 key 的 

hashCode()

 方法的返回值, 而是将 hashCode 的高位移到低位后 再与原值异或.

static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

　　因为 HashMap 用 

hash & (table.length-1)

代替了 模运算 , 如果直接使用 

hashCode()

 的返回值的话, 只有hash code的低位(如果 table.length 是2的n次方, 只有最低的 n - 1 位)会参加运算, 高位即使发生变化也会产生碰撞. 而 

hash()

 方法把 hashCode 的高位与低位异或, 相当于高位也参加了运算, 能够减少碰撞.

　　举个例子:
　　假设 table.length - 1 的 值为 0000 0111, 有两个hash code : 0001 0101 和 0000 0101. 这两个hash code 分别与 table.length - 1 做与运算之后的结果是一样的: 0000 0101; 将这两个hash code 的高位和低位异或之后分别得到: 0001 0100、 0000 0101, 此时再分别与 table.length - 1 做与运算的结果是 0000 0100 和 0000 0101, 不再碰撞了.

resize()

　　resize()

 方法负责初始化或扩容 table. 如果 table 为 null 初始化 table 为 一个长度为 threshold 或 DEFAULT_INITIAL_CAPACITY的表; 否则将 table 的长度加倍, 旧 table 中的元素要么呆在原来的 index 要么以2的幂为偏移量在新 table中移动:

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) {
// 旧 table 的容量已经达到最大, 不扩容, 返回旧表
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 将旧容量加倍作为新表容量, 如果新表容量没达到容量最大值, 并且旧容量大于等于默认容量, threshold 加倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
// 旧的threshold 不为 0 , 旧 threshold 作为新表的容量
newCap = oldThr;
else {               // zero initial threshold signifies using defaults
// 旧 threshold 为 0 , 用 DEFAULT_INITIAL_CAPACITY 作为新容量, 用默认值计算新 threshold
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// 之前没有计算过新 threshold , 计算 threshold
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) {
// 帮助 GC
oldTab[j] = null;
if (e.next == null)
// 这个桶里只有一个元素, 此处用位运算代替了模运算
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
// 如果这个 bucket 的结构是树, 将这个 bucket 中的元素分为高低两部分((e.hash & bit) == 0 就分在低的部分, bit 是 oldCap), 低的部分留在原位, 高的部分放到 newTab[j + oldCap]; 如果某一部分的元素个数小于 UNTREEIFY_THRESHOLD 将这一部分转换成链表形式, 否则就形成新的树结构
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 将普通结构的 bucket 中的元素分为高低两部分, 低的部分留在原位, 高的部分放到 newTab[j + oldCap]
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;
}

　　举个例子解释一下高低两部分的划分:

• 扩容前 table.length 是 0000 1000 记为 oldCap , table.length - 1 是 0000 0111 记为 oldN;
• 扩容后 table.length 是 0001 0000 记为 newCap, table.length - 1 为 0000 1111 记为 newN;
• 有两个Node, hash ( 

  hash()

   方法得到的值)分别为 0000 1101 和 0000 0101 记为 n1 和 n2;

　　在扩容前, n1 和 n2 显然是在一个 bucket 里的, 但在扩容后 n1 & newN 和 n2 & newN 的值分别是 0000 1101 和 0000 0101, 这是需要划分成两部分, 并且把属于高部分的 bin 移动到新的 bucket 里的原因.

　　扩容后, hash 中只会有最低的4位参加 index 的计算, 因此可以用第4位来判断属于高部分还是低部分, 也就可以用 

(hash & oldCap) == 0

 来作为属于低部分的依据了.

查找

　　查找方法只有 

get()

 和 

getOrDefault()

 两个, 都是调用了 

getNode()

方法:

public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}

@Override
public V getOrDefault(Object key, V defaultValue) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}

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) {
// table 已经被初始化且 table 的长度不为 0 且 对应的 bucket 里有 bin
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
// 第一个节点的 key 和 给定的 key 相同
return first;
if ((e = first.next) != null) {
// bucket 中还有下一个 bin
if (first instanceof TreeNode)
// 是树结构的 bucket, 调用树版本的 getNode 方法
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
// 在普通的链表中查找 key
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}

遍历

　　可以通过

entrySet()

、

keySet()

、

values()

分别获得 

EntrySet

、

KeySet()

和

Values

对象, 他们的迭代器都是

HashIterator

的子类.

fast-fail 和 modCount

　　HashMap 不是线程安全的, 并且实现了 fast-fail 机制. 当一个迭代器被创建的时候(或者迭代器自身的 remove() 方法被调用), 会记录当前的 modCount 作为期待中的 modCount, 并在操作中先检查当前 modCount 是不是和旧的 modCount 相同, 不同则会抛出

ConcurrentModificationException

.

　　任何结构修改(新增或删除节点)都会改变 modCount 的值.

新增和更新

　　1.8 之前有4个方法和构造器能够往 HashMap 中添加键值对: 以一个Map为参数的构造器、

put()

、

putAll()

、

putIfAbsent()

,

public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}

public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}

public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}

@Override
public V putIfAbsent(K key, V value) {
return putVal(hash(key), key, value, true, true);
}

　　他们分别调用了

putMapEntries()

和

putVal()

. 这两个方法中有一个参数 evict , 仅当初始化时(构造器中)为 false.

putVal() 方法

　　来看一下

putVal()

 方法:

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)
// table 未被初始化或者长度为 0 时, 执行 resize()
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// 对应的 bucket 里没有元素, 新建一个普通 Node 放到这个位置
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))))
// 第一个节点的 key 和 给定的 key 相同
e = p;
else if (p instanceof TreeNode)
// 树结构, 调用树版本的 putVal, 如果树结构中存在 key, 将会返回相应的 TreeNode, 否则返回 null
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 在链表中没有找到 key, 新建一个节点放到链表末尾
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))))
// key 相同 break
break;
p = e;
}
}
if (e != null) { // existing mapping for key
// key 在 map 中存在
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
// 覆盖旧值
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// key 之前在 map 中不存在, 发生了结构变化, modCount 增加 1
++modCount;
if (++size > threshold)
// 扩容
resize();
afterNodeInsertion(evict);
return null;
}

HashMap 提供了三个回调方法:

void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

putMapEntries() 方法

　　putMapEntries()

方法就简单多了

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
// table 还没有初始化, 计算出 threshold
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
// s 超过了 threshold, 扩容
resize();
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
// 调用 putVal() 方法, 将键值对放进 map
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}

删除

　　删除元素有三个方法, 还有 EntrySet 和 KeySet 的 remove 和 clear 方法:

public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}

@Override
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
}

public void clear() {
Node<K,V>[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}

removeNode() 方法

　　removeNode()

 方法有5个参数, 说明一下其中两个:

• matchValue 为 true 时, 只在 value 符合的情况下删除;
• movable 为 false 时, 删除时不移动其他节点, 只给树版本的删除使用.

final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
// table 已经被初始化且 table 的长度不为 0 且 对应的 bucket 里有 bin
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 第一个的 key 和给定的 key 相同
node = p;
else if ((e = p.next) != null) {
// bucket 中有不止一个 bin
if (p instanceof TreeNode)
// 树结构, 调用树版本的 getNode
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// 在普通的 bucket 中查找 node
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// 找到了 node , 并且符合删除条件
if (node instanceof TreeNode)
// 树结构, 调用树版本的 removeNode , 如果节点过少, 会转换成链表结构
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
// node 是链表的第一个元素
tab[index] = node.next;
else
// 不是第一个元素
p.next = node.next;
// 结构变化 modCount + 1
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}

总结

• HashMap 是一个基于哈希表的装箱了的 Map 的实现; 它的数据结构是一个桶的数组, 桶的结构可能是单向链表或者红黑树, 大部分是链表.
• table 的容量是2的幂, 因此可以用更高效的位运算替代模运算.
• HashMap 使用的 hash 值, 并不是 key 的 

  hashCode()

  方法所返回的值, 详细还是看上面吧.
• 一个普通桶中的 bin 的数量超过 

  TREEIFY_THRESHOLD

  , 并且 table 的容量大于 

  MIN_TREEIFY_CAPACITY

  , 这个桶会被转换成树结构; 如果 bin 数量大于

  TREEIFY_THRESHOLD

   , 但 table 容量小于 

  MIN_TREEIFY_CAPACITY

  , 会进行扩容.
• 每次扩容新 table 的容量是老 table 的 2 倍.
• 扩容时, 会将原来下标为 index 的桶里的 bin 分为高低两个部分, 高的部分放到 

  newTab[index + oldCap]

   上, 低的部分放在原位; 如果某部分的 bin 的个数小于 

  UNTREEIFY_THRESHOLD

   树结构将会转换成链表结构.

　　转自：https://www.cnblogs.com/FJH1994/p/10227048.html