源码分析之HashMap

概念

HashMapJava Collections FrameworkMap集合的一种实现。HashMap提供了一种简单实用的数据存储和读取方式。Map接口不同于List接口,属于集合框架的另一条支线,Map提供了键值对K-V数据存储模型,底层则是通过Hash表存储。

本文分析基于JDK1.8

类结构

HashMap实现了Map接口,Map接口设置一系列操作Map集合的方法,如:putgetremove…等方法,而HashMap也针对此有其自身对应的实现。

HashMap继承AbstractMap类。AbstractMap类对于Map接口做了基础的实现,实现了containsKeycontainsValue…等方法。

类成员

构造函数

HashMap提供四种构造函数。最为基础是如下这种:

HashMap(int initialCapacity, float loadFactor)
1
2
3
4
5
6
7
public HashMap(int initialCapacity, float loadFactor) {
...
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}

HashMap(int initialCapacity, float loadFactor)是最基础的构造函数。该构造函数提供两个参数initialCapacity(初始大小)loadFactor(加载因子)

  • initialCapacity默认值是16 (1 << 4),最大值是 1073 741 824(1 << 30),且大小必须是小于最大值的2的幂次方;
  • loadFactor默认值是0.75,作用是扩容时使用;

初始化的过程中将传入的参数loadFactor赋值给this.loadFactor,然后调用tableSizeFor(initialCapacity)方法将处理的结果值赋值给this.threshold;

thresholdHashMap判断size是否需要扩容的阈值。这里调用tableSizeFor(initialCapacity)来设置threshold;

tableSizeFor有啥用?

先抛出答案:tableSizeFor方法保证函数返回值是大于等于给定参数initialCapacity最小的2的幂次方的数值。

如何实现?

1
2
3
4
5
6
7
8
9
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

可以看出该方法是一系列的二进制位操作。先说明 |=的作用:a |= b 等同于 a = a|b。逐行分析tableSizeFor方法:

  • int n = cap - 1

    • 给定的cap减1,是为了避免参数cap本来就是2的幂次方,这样一来,经过后续的未操作的,cap将会变成2 * cap,是不符合我们预期的。
  • n |= n >>> 1

    • n >>> 1n无符号右移1位,即n二进制最高位的1右移一位;
    • n | (n >>> 1),导致的结果是n二进制的高2位值为1;

      目前n的高1~2位均为1

  • n |= n >>> 2

    • n继续无符号右移2位。
    • n | (n >>> 2),导致n二进制表示高3~4位经过运算值均为1

      目前n的高1~4位均为1

  • n |= n >>> 4

    • n继续无符号右移4位。
    • n | (n >>> 4),导致n二进制表示高5~8位经过运算值均为1

      目前n的高1~8位均为1

  • n |= n >>> 8

    • n继续无符号右移8位。
    • n | (n >>> 8),导致n二进制表示高9~16位经过运算值均为1

      目前n的高1~16位均为1

  • n |= n >>> 16

    • n继续无符号右移16位。
    • n | (n >>> 16),导致n二进制表示高17~32位经过运算值均为1

      目前n的高1~32位均为1

可以看出,无论给定cap(cap < MAXIMUM_CAPACITY )的值是多少,经过以上运算,其值的二进制所有位都会是1。再将其加1,这时候这个值一定是2的幂次方。当然如果经过运算值大于MAXIMUM_CAPACITY,直接选用MAXIMUM_CAPACITY

这里可以举个栗子,假设给定的cap的值为20

  • int n = cap - 1; —> n = 19(二进制表示:0001 0011)

  • n |= n >>> 1;

1
2
3
n -> 0001 0011
n >>> 1 -> 0000 1001
n |= n >>> 1 -> 0001 1011
  • n |= n >>> 2;
1
2
3
n -> 0001 1011
n >>> 2 -> 0000 1101
n |= n >>> 2 -> 0001 1111

此时n所有位均为1,后续的位操作均不再改变n的值。

1
n + 1 -> 0010 0000 (32)

最终,tableSizeFor(20)的结果为32(2^5)

至此tableSizeFor如何保证cap2的幂次方已经显而易见了。那么问题来了,为什么cap要保持为2的幂次方?

为什么cap要保持为2的幂次方?

cap要保持为2的幂次方主要原因是HashMap中数据存储有关。

JDK1.8中,HashMapkeyHash值由Hash(key)方法(后面会详细分析)计算得来。

HashMap中存储数据tableindex是由keyHash值决定的。在HashMap存储数据的时候,我们期望数据能够均匀分布,以避免哈希冲突。自然而然我们就会想到去用%取余的操作来实现我们这一构想。

这里要了解到一个知识:取余(%)操作中如果除数是2的幂次方则等同于与其除数减一的与(&)操作

这也就解释了为啥一定要求cap要为2的幂次方。再来看看tableindex的计算规则:

1
2
3
4
5
index = e.hash & (newCap - 1)
等同于:
index = e.hash % newCap

采用二进制位操作&,相对于%,能够提高运算效率,这就是要求cap的值被要求为2幂次方的原因。

Node

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}

Node<K,V> 类HashMap中的静态内部类,实现Map.Entry<K,V>接口。 定义了key键、value值、next节点,也就是说元素之间构成了单向链表。

Node[] table

Node<K,V>[] tableHashMap底层存储的数据结构,是一个Node数组。上面得知Node类为元素维护了一个单向链表。

至此,HashMap存储的数据结构也就很清晰了:维护了一个数组,每个数组又维护了一个单向链表。之所以这么设计,考虑到遇到哈希冲突的时候,同indexvalue值就用单向链表来维护。

hash(K,V) 方法

HashMaptableindex是由Key的哈希值决定的。HashMap并没有直接使用keyhashcode(),而是经过如下的运算:

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

而上面我们提到index的运算规则是e.hash & (newCap - 1)。由于newCap2的幂次方,那么newCap - 1的高位应该全部为0。如果e.hash值只用自身的hashcode的话,那么index只会和e.hash低位做&操作。这样一来,index的值就只有低位参与运算,高位毫无存在感,从而会带来哈希冲突的风险。所以在计算key的哈希值的时候,用其自身hashcode值与其低16位做异或操作。这也就让高位参与到index的计算中来了,即降低了哈希冲突的风险又不会带来太大的性能问题。

put(K,V) 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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)
// tab 为空,调用resize()初始化tab。
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// key没有被占用的情况下,将value封装为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相同,p赋值给e
e = p;
else if (p instanceof TreeNode)
// 如果p是红黑树类型,调用putTreeVal方式赋值
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// index 相同的情况下
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 如果p的next为空,将新的value值添加至链表后面
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 如果链表长度大于8,链表转化为红黑树,执行插入
treeifyBin(tab, hash);
break;
}
// key相同则跳出循环
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;
//根据规则选择是否覆盖value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
// size大于加载因子,扩容
resize();
afterNodeInsertion(evict);
return null;
}

在构造函数中最多也只是设置了initialCapacityloadFactor的值,并没有初始化tabletable的初始化工作是在put方法中进行的。

resize() 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
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) {
// table已存在
if (oldCap >= MAXIMUM_CAPACITY) {
// oldCap大于MAXIMUM_CAPACITY,threshold设置为int的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//newCap设置为oldCap的2倍并小于MAXIMUM_CAPACITY,且大于默认值, 新的threshold增加为原来的2倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
// threshold>0, 将threshold设置为newCap,所以要用tableSizeFor方法保证threshold是2的幂次方
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 默认初始化,cap为16,threshold为12。
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// newThr为0,newThr = newCap * 0.75
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 新生成一个table数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// oldTab 复制到 newTab
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)
// e为红黑树的情况
((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;
}

remove(key) 方法 & remove(key, value) 方法

remove(key) 方法 和 remove(key, value) 方法都是通过调用removeNode的方法来实现删除元素的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// index 元素只有一个元素
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
// index处是一个红黑树
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// index处是一个链表,遍历链表返回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)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}