最近公司解散了,找工作期间无聊,写写博客。解读一下jdk1.8中HashMap的源码。如有解析不对,欢迎评论指教
作者:郑嘉裕
微信:vn1906(欢迎博客好友共同探讨技术问题)
HashMap设计思路:
1、简单分析数组跟链表:先从数组跟链表讲起吧,数组的遍历为什么快?链表的遍历为什么慢?这里就再解释一下,因为数组是基于下标查询的,比如int a[] = {1,2,3,4,5}, 你要查找第三个元素,可以直接 a[2],是可以直接拿到值的,因为数组是连续的内存空间,int又是固定的空间,所以找第几个的时候,可以直接通过偏移获取到,不懂得可以去看下c中的指针,可以让你更好理解。 但是链表呢,因为是不连续的内存空间地址,你要拿第三个,需要去找到表头,再通过next找到第二个,再next找到第三个。所以找第几个元素的时候, 链表需要遍历。所以链表的性能就比较差。这里就不对比数组跟链表了。
2、HashMap的存储结构:基于数组的特性,我们可以进行下面的思考
假设 HashMap<key,value>,以key的hashcode为数组的下标可不可以呢?理想肯定是好的,但是现实嘛,肯定会做一下修改。在不重写hashcode的情况下,比如 Integer的hash是本身。大家知道数组是需要预先创建的,如果你一开始put进map的值是999999,那hashmap的中对于key这个数组大小岂不是需要999999?显然不合理。所以对于这个实现,hashmap做了优化,那就是取模,比如 key作为寻址,数组初始化长度是10,那999999取完模也就是9而已。这样就显得比较合理了。那比如 99跟9都对10取模,那岂不是都落到下标为9的位置?那怎么存储呢?答案是,在9这个位置存一个链表。大家都知道,链表是不连续的,所以链表理论上是可以无限大的。所以hashmap的存储结构我们暂时可以理解为 数组加链表如图,用数组长度为10,key元素分别为99,9,8,7的存储位置。
99%10=9;
9%10=9;
8%10=8;
7%10=7;
数组 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
链表 | 表0 | 表1 | 表2 | 表3 | 表4 | 表5 | 表6 | 表7 | 表8 | 表9 |
7 | 8 | 9 | ||||||||
99 | ||||||||||
看完大家也就知道了大概的思路了,就是数组里面的元素放着一个链表
最理想的存储结构是怎样呢?那就是10个数据都落在不一样的下标,切只有一个元素。也就是说,每个数组的位置都是一个节点。这样的效率是最高的,就比如我们之前讲的,用数组的下标去取值那样a[key.hashCode] ,这样又快又直接。但是现实肯定是不丰满。最主要是不可能一下子创建这么大的数组,所以数组里的元素存放一个链表。。
3、HashMap的查找
既然存储结构我们知道了,那如上面的存储表,找一个key为9的值,那我们就先取模,定位到a[9],然后遍历该链表,直到找到key为9的Node。讲到这里大家也就应该直到为什么HashMap中的key不能重复的原因了吧。
4、HashMap的hash()方法
按照我们之前的思路,我们大概有了头绪,只是人家HashMap又做了一点优化,那就是对于key的hashcode又再做了一次hash处理。先贴一下源码
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
代码的意思是什么呢?就是右移16位,再做一次异或。
复习一下 ^(异或)
0^0=0;
1^1=0;
0^1=1;
1^0=1
原 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | 1 |
>>>16 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
^ | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 1 | 0 | 0 | 0 |
这段代码的意思大概就是:混合原始哈希码的高位跟低位,以此来加大低位的随机性。为什么要这样子呢?理解不了我觉得也无所谓,你就先按你的理解就当做它没做这个处理吧。
5、HashMap的初始化数组长度
现在我们来看看hashmap的初始化。
/**
* The default initial capacity - MUST be a power of two.
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
这个表示,初始化的时候数组长度为16(有些人叫桶),这里分析一下。为什么是16,而不是15,14 ,13?
首先人家告诉你的是,必须是2的平方倍。16=2^4;
接下来我们就来分析为什么是 16(2的平方倍)
很简单,先看看他怎么存一个数据的,源码看不懂不要管。略过
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;
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);
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))))
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)
resize();
afterNodeInsertion(evict);
return null;
}
我们分析重点的就好了,代码只是贴出来看看,里面的table是上面定义的table,看下表的代码。大概你们可以猜出来就是我们前面分析的数组。
transient Node<K,V>[] table;
在分析一下 put的操作,n=tab.length 也就是说 n是我们上面所说的数组长度,
(n-1)&hash 这里大家可以看到。 这个跟我们上面所说的原理差不多, 但是它进行的是一个&操作。下面我们来分析一下这个算法
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
首先,我们来看看,n-1的情况。 拿16来说也就是2^4。
假设一个值得hash是9
15(n-1) | 1 | 1 | 1 | 1 | |
9 | 1 | 0 | 1 | 0 | |
结果 | 1 | 0 | 1 | 0 |
&的操作是,都是1,结果才是1
如果是0-14的数。基本上就全部散列在我们所期望的数组下面的。不会出现重复,我们来看这样一个情况.如果是n-2也就是n=15
14(n-1) | 1 | 1 | 1 | 0 | |
9 | 1 | 0 | 1 | 0 | |
结果 | 1 | 0 | 1 | 0 |
这样对比起来似乎没什么关系,但是仔细看最后一位。那就是 位数是1跟0做了&运算之后都为0了。这样就出现什么情况呢
14(n-1) | 1 | 1 | 1 | 0 | |
9 | 1 | 0 | 1 | 0 | |
10 | 1 | 0 | 1 | 1 | |
结果 | 1 | 0 | 1 | 0 |
这时候大家应该可以发现。9跟10位置一样。这样就不够散列稀疏了。有人问那如果长度 n=16,那9跟24的下标也一样啊。这是两个维度。也就是下面会讲的HashMap的扩容
讲到这里大家已经知道了,为什么HashMap的桶(数组)为2的倍数了,那就是 1111111111111111。都要是1
6、HashMap的扩容原理
6.1这里先来讲一下,为什么要扩容?
按照我们之前讲的数据结构,HashMap的存储,大家应该知道查找是怎样了吧。就是先hash,再进行&运算获得数组下标。再遍历链表。如果能理解到这里,我觉得你已经大概了解hashmap了。这里有个重点。就是如果数组长度永远是16,如果数据量很大的时候,就会出现hash冲突,也就是说。不同的数落在了同一个桶(数组下标),如果数据量巨大的时候。那么桶里面的数据也非常大,按照之前讲的。桶里面是一个链表,那就说明还是需要遍历。当链表很大的时候,那遍历速度就慢了。这个情况之前已经见过了,不再累赘。所以hashmap就需要扩容,好让它可以达到我们之前讲的,最好是一个桶一个元素。
6.2什么时候扩容?
//这里定义为一个阈值,就是HashMap中数据的个数。
threshold=capacity*loadFactor
capacity//桶的数量也就是我们之前说的数组
loadFactor//装载因子,默认是0.75
当进行put的时候,hashmap里面的元素大于threshold(阈值),这个时候就进行扩容
6.3怎么扩容?
这个问题我说了不算,源码说了算,我们继续看源码,代码很多,大家不想看就忽略吧
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) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//重点看这里
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1;
}
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;
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;
}
扩容就是一倍,为什么是一倍。 上面讲解为什么是16的时候已经见过了。2的N次方。由于 阈值是int类型,所以到了int的最大值就不扩容了。
7、总结
大概已经讲了hashmap的原理,如果想更深入的理解,建议看看源码,如果有讲得不对可以指出
面试的时候人家问到的时候,总结一下几点
1、hashmap的结构是数组加链表,或者说桶里面放着一个链表
2、初始化长度为16,桶的数量为2N次方,因为 &运算是跟 桶数-1进行操作的。 为了保证每个位都是1,实现离散
3、当hashmap里面元素的数量>桶*加载因子的时候,实现扩容。加载因子默认是0.75
4、扩容后的长度为原来的一倍。
5、使用hashmap的时候,如果预知数量比较大。可以初始化一个值。根据加载因子去推算。不然会hash冲突,导致一直扩容。
6、源码里操作都没有同步或者加锁,所以hashmap是线程不安全的。