HashMap:JDK7 与 JDK8 的实现

JDK7中的HashMap

HashMap底层维护一个数组,数组中的每一项都是一个Entry:

1 transient Entry<K,V>[] table;

我们向在HashMap 存放的对象实际上是存储在该数组当中的:Map中的keyvalue则以Entry的形式存放在数组中。

 

1 static class Entry<K,V> implements Map.Entry<K,V> {
2         final K key;
3         V value;
4         Entry<K,V> next;
5         int hash;
6 }

 

而这个Entry应该放在数组的哪一个位置上(这个位置通常称为位桶或者hash桶,即hash值相同的Entry会放在同一位置,用链表相连),是通过keyhashCode来计算的。

 

1 final int hash(Object k) {
2         int h = 0;
3         h ^= k.hashCode();
4         h ^= (h >>> 20) ^ (h >>> 12);
5         return h ^ (h >>> 7) ^ (h >>> 4);
6 }

 

通过hash计算出来的值将会使用indexFor方法找到它应该所在的table下标:

 

1 static int indexFor(int h, int length) {
2         return h & (length-1);
3 }

 

这个方法其实相当于对table.length取模。当两个key通过hashCode计算相同时,则发生了hash冲突(碰撞)HashMap解决hash冲突的方式是用链表。当发生hash冲突时,则将存放在数组中的Entry设置为新值的next(这里要注意的是,比如ABhash后都映射到下标i中,之前已经有A了,当map.put(B)时,将B放到下标i中,A则为Bnext,所以新值存放在数组中,旧值在新值的链表上),如图所示:

所以当hash冲突很多时,HashMap退化成链表。

 

 

总结一下map.put的过程:

 

当向 HashMap put 一对键值时,它会根据 keyhashCode 值计算出一个位置, 该位置就是此对象准备往数组中存放的位置。 

 

如果该位置没有对象存在,就将此对象直接放进数组当中;如果该位置已经有对象存在了,则顺着此存在的对象的链开始寻找(为了判断是否是否值相同,map不允许<key,value>键值对重复), 如果此链上有对象的话,再去使用 equals方法进行比较,如果对此链上的每个对象的 equals 方法比较都为 false,则将该对象放到数组当中,然后将数组中该位置以前存在的那个对象链接到此对象的后面。 

 

值得注意的是,当keynull时,都放到table[0]

 

 

 1 private V putForNullKey(V value) {
 2         for (Entry<K,V> e = table[0]; e != null; e = e.next) {
 3             if (e.key == null) {
 4                 V oldValue = e.value;
 5                 e.value = value;
 6                 e.recordAccess(this);
 7                 return oldValue;
 8             }
 9         }
10         modCount++;
11         addEntry(0, null, value, 0);
12         return null;
13 }

 

size大于threshold时,会发生扩容。 threshold等于capacity*load factor

 

1 void addEntry(int hash, K key, V value, int bucketIndex) {
2         if ((size >= threshold) && (null != table[bucketIndex])) {
3             resize(2 * table.length);
4             hash = (null != key) ? hash(key) : 0;
5             bucketIndex = indexFor(hash, table.length);
6         }
7 
8         createEntry(hash, key, value, bucketIndex);
9 }

 

 

jdk7resize,只有当 size>=threshold并且 table中的那个槽中已经有Entry时,才会发生resize。即有可能虽然size>=threshold,但是必须等到每个槽都至少有一个Entry时,才会扩容。还有注意每次resize都会扩大一倍容量默认的容量非常小 若存储的数据太多的话 需要resize的次数就会越多 resize是空间和时间消耗都非常惊人的内部操作 他需要new一个容量更大的table 然后把原来的table从新散列到新的table中去所以,当目标数据太多时  可以增大初始化因子 使得一开始就创建一个大容量的table 减少resize的次数。

 

JDK8中的HashMap

 

一直到JDK7为止,HashMap的结构都是这么简单,基于一个数组以及多个链表的实现,hash值冲突的时候,就将对应节点以链表的形式存储。

这样子的HashMap性能上就抱有一定疑问,如果说成百上千个节点在hash时发生碰撞,存储一个链表中,那么如果要查找其中一个节点,那就不可避免的花费O(N)的查找时间,这将是多么大的性能损失。这个问题终于在JDK8中得到了解决。再最坏的情况下,链表查找的时间复杂度为O(n),而红黑树一直是O(logn),这样会提高HashMap的效率。

JDK7HashMap采用的是位桶+链表的方式,即我们常说的散列链表的方式,而JDK8中采用的是位桶+链表/红黑树(有关红黑树请查看红黑树)的方式,也是非线程安全的。当某个位桶的链表的长度达到某个阀值的时候,这个链表就将转换成红黑树。

 

JDK8中,当同一个hash值的节点数不小于8时,将不再以单链表的形式存储了,会被调整成一颗红黑树(上图中null节点没画)。这就是JDK7JDK8HashMap实现的最大区别。

接下来,我们来看下JDK8HashMap的源码实现。

JDKEntry的名字变成了Node,原因是和红黑树的实现TreeNode相关联。

 

1 transient Node<K,V>[] table;

 

当冲突节点数不小于8-1时,转换成红黑树。

1 static final int TREEIFY_THRESHOLD = 8;

put方法在JDK8中有了很大的改变

 

 

 1 public V put(K key, V value) {
 2         return putVal(hash(key), key, value, false, true);
 3  }
 4 
 5 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 6                    boolean evict) {
 7         Node<K,V>[] tab;
 8     Node<K,V> p; 
 9     int n, i;
10     //如果当前map中无数据,执行resize方法。并且返回n
11         if ((tab = table) == null || (n = tab.length) == 0)
12             n = (tab = resize()).length;
13      //如果要插入的键值对要存放的这个位置刚好没有元素,那么把他封装成Node对象,放在这个位置上就完事了
14         if ((p = tab[i = (n - 1) & hash]) == null)
15             tab[i] = newNode(hash, key, value, null);
16     //否则的话,说明这上面有元素
17         else {
18             Node<K,V> e; K k;
19               //如果这个元素的key与要插入的一样,那么就替换一下,也完事。
20             if (p.hash == hash &&
21                 ((k = p.key) == key || (key != null && key.equals(k))))
22                 e = p;
23               //1.如果当前节点是TreeNode类型的数据,执行putTreeVal方法
24             else if (p instanceof TreeNode)
25                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
26             else {
27                //还是遍历这条链子上的数据,跟jdk7没什么区别
28                 for (int binCount = 0; ; ++binCount) {
29                     if ((e = p.next) == null) {
30                         p.next = newNode(hash, key, value, null);
31                        //2.完成了操作后多做了一件事情,判断,并且可能执行treeifyBin方法
32                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
33                             treeifyBin(tab, hash);
34                         break;
35                     }
36                     if (e.hash == hash &&
37                         ((k = e.key) == key || (key != null && key.equals(k))))
38                         break;
39                     p = e;
40                 }
41             }
42             if (e != null) { // existing mapping for key
43                 V oldValue = e.value;
44                 if (!onlyIfAbsent || oldValue == null) //true || --
45                     e.value = value;
46            //3.
47                 afterNodeAccess(e);
48                 return oldValue;
49             }
50         }
51         ++modCount;
52         //判断阈值,决定是否扩容
53         if (++size > threshold)
54             resize();
55         //4.
56         afterNodeInsertion(evict);
57         return null;
58     }

treeifyBin()就是将链表转换成红黑树。

之前的indefFor()方法消失 了,直接用(tab.length-1)&hash,所以看到这个,代表的就是数组的下角标。

 

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

 

posted @ 2017-06-27 20:57  yweihainan  阅读(446)  评论(0编辑  收藏  举报