在我们实际的项目中,HashMap这个集合类经常被用到,可是就是这么一个常用的集合类,却往往成了咱们面试中的绊脚石,即便你是个初级程序员,也常会让你谈谈HashMap的底层原理,今天咱们就来扒一扒这个HashMap的庐山真面目。
一、HashMap的特点
- 元素以键值对的方式存储,并且允许使用null作为键值;
- key不允许重复,因此只能有一个键为null;
- HashMap不能保证放入元素的顺序,它是无序的;
- HashMap是线程不安全的;
二、HashMap数据结构
JDK1.8之前,数据结构为:数组+列表
JDK1.8及之后,数据结构为:数组+列表+红黑树
为什么JDK1.8会引入红黑树数据结构呢?
我们来详细看下JDK1.8 HashMap的put和get方法就秒懂了。
HashMap内部有一个属性
transient Node<K,V>[] table;
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;
}
}
这个属性是一个Node数组,Node是一个链表的数据结构,所以整个就是数据+链表的数据结构。
put方法:
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)
//关键点1
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)//关键点2
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))))//关键点3
e = p;
else if (p instanceof TreeNode)//关键点4
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {//关键点5
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // 关键点6
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;
}
}
++modCount;
if (++size > threshold)
//关键点7
resize();
afterNodeInsertion(evict);
return null;
}
如上代码中表示了几个关键位置,下面针对关键位置进行说明:
关键点1:
首次put时,调用resize方法创建table数组,默认Node<K,V>数组长度为16,因子为0.75*16(即超过该长度后,自动扩容数组,扩容后的数组长度等于原长度的2倍,而且长度只能是2的N次方);
关键点2:
通过“(数组长度-1)&hash”得到下标值,这里引出两个问题:
A.为什么不是使用“数组长度%hash”得到数组下标呢?
这个是基于计算机本身的特性,因为&运算性能比取模的性能更高,并且存在数学恒等式:n%hash=(n-1)&hash。
B.为什么数组的长度必须是2的N次方?
如果数组长度不是2的N次方会出现什么结果。我们假设数组长度为10,按照上述(数组长度-1)&hash计算方法,计算过程如下:(10-1) & hash,转换成二进制后:1001&hash,根据&符号的特点,所有与0做&号运算的结果都为0,也就是通过1001&hash最终计算的结果只能是X00X,在明确点,计算结果只能是:0000/0001/1000/1001,既然如此,那有6个数组位永远都是空闲的,所以数组的长度只能是2的N次方。
C.如果多个线程同时进入执行到该代码块,并且计算的下标值是一样的,则会出现数据丢失。
关键点3:
如果对应的key等于传入的key,则表示就是自己,后续直接e.value=value将老的值替换成新值。
关键点4:
如果是红黑树节点,则添加到树中。
关键点5:
挨个找数组下标对应的链表,直到找到最后一个节点(尾插法),找到尾节点后,将新的节点设置为尾节点的子节点;这里需要注意,多线程的情况下,会出现数据丢失。
在jdk1.8之前,因为采用的是头插法,在扩容时当两个线程同时检测到hashmap需要扩容,在同时扩容的时候有可能会造成链表的循环,主要原因就是,采用头插法,新链表与旧链表的顺序是反的,具体感兴趣的朋友可以上网百度下,再次不在累述。
关键点6:
如果链表的长度超过8,则转换为红黑树数据结构。
关键点7:
如果元素的个数大于扩容因子数,则调用resize开始扩容,扩容时需要将数组中原有的数据重新计算下标位置进行转移。
Get方法:
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)
//关键点1
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//关键点2
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
以上是get方法代码,以上我们可以看出,首先是根据key的hash值,得到所在的数组下标位置,然后进一步从链表或红黑树查询,具体包括两个关键点:
关键点1:
如果为红黑树节点,则根据树形规则查找,会调用如下find方法,因为红黑树是一个二叉树,这里比较节点的hash值和要找的hash值,如果则节点值大于待查找的hash值,则从左边节点树找,否则从右边节点树找。
红黑树特点:
- 红黑树根节点必须为黑色;
- 红黑树每个叶子节点都要是黑色的空节点,也就是说,叶子节点不存储数据;
- 在红黑树中任何相邻的节点都不能同时为红色,也就是说,红色节点是被黑色节点隔开的;
- 红黑树中每个节点,从该节点到达其可达叶子节点的所有路径,都要包含相同数目的黑色节点;
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
if ((ph = p.hash) > h)//判断点
p = pl;
else if (ph < h)
p = pr;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.find(h, k, kc)) != null)
return q;
else
p = pl;
} while (p != null);
return null;
}
关键点2:
如果是链表,则while循环挨个往后找,直到找到,这里是时间复杂度为O(n)。
以上是HashMap的核心内容,其他还有诸多细节,朋友们可以调试进入代码一探究竟。