本文来源于:http://www.2cto.com/kf/201505/401433.html
这几天学习了HashMap的底层实现,发现关于HashMap实现的博客还是很多的,但几乎都是JDK1.6版本的,而我的JDK版本是1.8.0_25,对比之下,发现Hashmap的实现变动较大。这篇博客断断续续写了一天,理解不当之处,欢迎指正。
在JDK1.6中,HashMap采用位桶+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。而JDK1.8中,HashMap采用位桶+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找时间。
下面直接贴代码:
1 涉及到的数据结构:处理hash冲突的链表和红黑树以及位桶
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
|
//Node是单向链表,它实现了Map.Entry接口
static
class
Node<k,v>
implements
Map.Entry<k,v> {
final
int
hash;
final
K key;
V value;
Node<k,v> next;
//构造函数Hash值 键 值 下一个节点
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;
}
//判断两个node是否相等,若key和value都相等,返回true。可以与自身比较为true
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
;
}
}</k,v></k,v></k,v></k,v>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
//红黑树
static
final
class
TreeNode<k,v>
extends
LinkedHashMap.Entry<k,v> {
TreeNode<k,v> parent;
// 父节点
TreeNode<k,v> left;
//左子树
TreeNode<k,v> right;
//右子树
TreeNode<k,v> prev;
// needed to unlink next upon deletion
boolean
red;
//颜色属性
TreeNode(
int
hash, K key, V val, Node<k,v> next) {
super
(hash, key, val, next);
}
//返回当前节点的根节点
final
TreeNode<k,v> root() {
for
(TreeNode<k,v> r =
this
, p;;) {
if
((p = r.parent) ==
null
)
return
r;
r = p;
}
}</k,v></k,v></k,v></k,v></k,v></k,v></k,v></k,v></k,v>
|
1
|
transient
Node<k,v>[] table;
//存储(位桶)的数组</k,v>
|
有了以上3个数据结构,只要有一点数据结构基础的人,都可以大致联想到HashMap的实现了。首先有一个每个元素都是链表(可能表述不准确)的数组,当添加一个元素(key-value)时,就首先计算元素key的hash值,以此确定插入数组中的位置,但是可能存在同一hash值的元素已经被放在数组同一位置了,这时就添加到同一hash值的元素的后面,他们在数组的同一位置,但是形成了链表,所以说数组存放的是链表。而当链表长度太长时,链表就转换为红黑树,这样大大提高了查找的效率。
下面继续看代码实现:
2 HashMap主要属性
说一下填充比,默认值为0.75,如果实际元素所占容量占分配容量的75%时就要扩容了。如果填充比很大,说明利用的空间很多,但是查找的效率很低,因为链表的长度很大(当然最新版本使用了红黑树后会改进很多),HashMap本来是以空间换时间,所以填充比没必要太大。但是填充比太小又会导致空间浪费。如果关注内存,填充比可以
稍大,如果主要关注查找性能,填充比可以稍小。
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
|
public
class
HashMap<k,v>
extends
AbstractMap<k,v>
implements
Map<k,v>, Cloneable, Serializable {
private
static
final
long
serialVersionUID = 362498820763181265L;
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;
//填充比
//当add一个元素到某个位桶,其链表长度达到8时将链表转换为红黑树
static
final
int
TREEIFY_THRESHOLD =
8
;
static
final
int
UNTREEIFY_THRESHOLD =
6
;
static
final
int
MIN_TREEIFY_CAPACITY =
64
;
transient
Node<k,v>[] table;
//存储元素的数组
transient
Set<map.entry<k,v>> entrySet;
transient
int
size;
//存放元素的个数
transient
int
modCount;
//被修改的次数fast-fail机制
int
threshold;
//临界值 当实际大小(容量*填充比)超过临界值时,会进行扩容
final
float
loadFactor;
//填充比(......后面略)</map.entry<k,v></k,v></k,v></k,v></k,v>
|
3 构造方法
HashMap的构造方法有4种,主要涉及到的参数有,指定初始容量,指定填充比和用来初始化的Map,直接看代码
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
|
/* ---------------- Public operations -------------- */
//构造函数1
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;
this
.threshold = tableSizeFor(initialCapacity);
//新的扩容临界值
}
//构造函数2
public
HashMap(
int
initialCapacity) {
this
(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//构造函数3
public
HashMap() {
this
.loadFactor = DEFAULT_LOAD_FACTOR;
// all other fields defaulted
}
//构造函数4用m的元素初始化散列映射
public
HashMap(Map<!--?
extends
K, ?
extends
V--> m) {
this
.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m,
false
);
}
|
4 扩容机制
构造hash表时,如果不指明初始大小,默认大小为16(即Node数组大小16),如果Node[]数组中的元素达到(填充比*Node.length)
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
|
//可用来初始化HashMap大小 或重新调整HashMap大小 变为原来2倍大小
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) {
//超过1>>30大小,无法扩容只能改变 阈值
threshold = Integer.MAX_VALUE;
return
oldTab;
}
else
if
((newCap = oldCap <<
1
) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//新的容量为旧的2倍 最小也是16
newThr = oldThr <<
1
;
// 扩容阈值加倍
}
else
if
(oldThr >
0
)
newCap = oldThr;
//oldCap=0 ,oldThr>0此时newThr=0
else
{
//oldCap=0,oldThr=0 相当于使用默认填充比和初始容量 初始化
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
;
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;
}</k,v></k,v></k,v></k,v></k,v></k,v></k,v></k,v></k,v>
|
很明显,因为存在旧数组元素复制到新数组中的操作,扩容非常耗时。
5 确定元素put/get的数组Node[]位置
1
2
3
4
|
static
final
int
hash(Object key) {
int
h;
return
(key ==
null
) ?
0
: (h = key.hashCode()) ^ (h >>>
16
);
}
|
1
|
public
native
int
hashCode();
|
首先由key值通过hash(key)获取hash值h,再通过 h&(length-1)得到所在数组位置。一般对于哈希表的散列常用的方法有直接定址法,除留余数法等,既要便于计算,又能减少冲突。
在Hashtable中就是通过除留余数法散列分布的,具体如下:
1
|
int
index = (hash &
0x7FFFFFFF
) % tab.length;
|
在HashMap实现中还可以看到如下代码取代了以前版本JDK1.6的while循环来保证哈希表的容量一直是2的整数倍数,用移位操作取代了循环移位。
1
2
3
4
5
6
7
8
9
10
|
//这段代码保证HashMap的容量总是2的n次方
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
;
}
|
的最后一位肯定为0,即索引位置肯定是偶数,这样数组的奇数位置全部没有放置元素,浪费了大量空间。
简而言之:length为2的幂保证了按位与最后一位的有效性,使哈希表散列更均匀。
6 下面分析HashMap的最常用操作put和get
注意HashMap中key和value都容许为null
直接上代码:
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
|
//***********************************get***************************************************/
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;
//hash & (length-1)得到对象的保存位
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
) {
//如果第一个节点是TreeNode,说明采用的是数组+红黑树结构处理冲突
//遍历红黑树,得到节点值
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
;
}</k,v></k,v></k,v></k,v></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
|
//************************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;
//如果tab为空或长度为0,则分配内存resize()
if
((tab = table) ==
null
|| (n = tab.length) ==
0
)
n = (tab = resize()).length;
//(n - 1) & hash找到put位置,如果为空,则直接put
if
((p = tab[i = (n -
1
) & hash]) ==
null
)
tab[i] = newNode(hash, key, value,
null
);
else
{
Node<k,v> e; K k;
//第一节节点hash值同,且key值与插入key相同
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) {
//p第一次指向表头,以后依次后移
if
((e = p.next) ==
null
) {
//e为空,表示已到表尾也没有找到key值相同节点,则新建节点
p.next = newNode(hash, key, value,
null
);
//新增节点后如果节点个数到达阈值,则将链表转换为红黑树
if
(binCount >= TREEIFY_THRESHOLD -
1
)
// -1 for 1st
treeifyBin(tab, hash);
break
;
}
//容许null==null
if
(e.hash == hash &&((k = e.key) == key || (key !=
null
&& key.equals(k))))
break
;
p = e;
//更新p指向下一个节点
}
}
//更新hash值和key值均相同的节点Value值
if
(e !=
null
) {
// existing mapping for key
V oldValue = e.value;
if
(!onlyIfAbsent || oldValue ==
null
)
e.value = value;
afterNodeAccess(e);
return
oldValue;
}
}
++modCount;
if
(++size > threshold)
resize();
afterNodeInsertion(evict);
return
null
;
}</k,v></k,v></k,v></k,v>
|
下面简单说下添加键值对put(key,value)的过程:(事实上,直接看代码逻辑更清晰些)
1判断键值对数组tab[]是否为空或为null,否则resize();
2根据键值key计算hash值得到插入的数组索引i,如果tab[i]==null,直接新建节点添加,否则转入3
3判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理。