最新的HashMap及性能优化
2019-07-07

这几天学习了HashMap的底层实现,但是发现好几个版本的,代码不一,而且看了Android包的HashMap和JDK中的HashMap的也不是一样,原来他们没有指定JDK版本,很多文章都是旧版本的。现在我来分析一哈最新的的HashMap及性能优化。

在,中,HashMap采用位桶+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。而中,HashMap采用位桶+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找时间。

简单说下HashMap的实现原理:

首先有一个每个元素都是链表(可能表述不准确)的数组,当添加一个元素(key-value)时,就首先计算元素key的hash值,以此确定插入数组中的位置,但是可能存在同一hash值的元素已经被放在数组同一位置了,这时就添加到同一hash值的元素的后面,他们在数组的同一位置,但是形成了链表,同一各链表上的Hash值是相同的,所以说数组存放的是链表。而当链表长度太长时,链表就转换为红黑树,这样大大提高了查找的效率。

     当链表数组的容量超过初始容量的时,再散列将链表数组扩大2倍,把原链表数组的搬移到新的数组中

即HashMap的原理图是:

一,中的涉及到的数据结构

1,位桶数组

  1. transient Node

         2,数组元素Node

 1//Node是单向链表,它实现了接口   2staticclass Nodeimplements  {  
 3finalint hash;  
 4final K key;  
 5    V value;  
 6     Node next;  
 7//构造函数Hash值 键 值 下一个节点   8     Node(int hash, K key, V value, Node next) {  
 9this.hash = hash;  
10this.key = key;  
11this.value = value;  
12this.next = next;  
13    }  
1415publicfinal K getKey()        { return key; }  
16publicfinal V getValue()      { return value; }  
17publicfinal String toString() { return key + = + value; }  
1819publicfinalint hashCode() {  
20return (key) ^ (value);  
21    }  
2223publicfinal V setValue(V newValue) {  
24         V oldValue = value;  
25         value = newValue;  
26return oldValue;  
27    }  
28//判断两个node是否相等,若key和value都相等,返回true。可以与自身比较为true  29publicfinalboolean equals(Object o) {  
30if (o == this)  
31returntrue;  
32if (o instanceof ) {  
33              e = ()o;  
34if ((key, ()) &&  
35                (value, ()))  
36returntrue;  
37        }  
38returnfalse;  
39     }

3,红黑树

 1//红黑树   2staticfinalclass TreeNodeextends LinkedHash {  
 3     TreeNodeparent;  // 父节点   4     TreeNodeleft; //左子树   5     TreeNoderight;//右子树   6     TreeNodeprev;    // needed to unlink next upon deletion   7boolean red;    //颜色属性   8     TreeNode(int hash, K key, V val, Node next) {  
 9super(hash, key, val, next);  
10    }  
1112//返回当前节点的根节点  13final TreeNode root() {  
14for (TreeNoder = this, p;;) {  
15if ((p = ) == null)  
16return r;  
17             r = p;  
18        }  
19     }

二,源码中的数据域

加载因子(默认):为什么需要使用加载因子,为什么需要扩容呢因为如果填充比很大,说明利用的空间很多,如果一直不进行扩容的话,链表就会越来越长,这样查找的效率很低,因为链表的长度很大(当然最新版本使用了红黑树后会改进很多),扩容之后,将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置,这样就减少了每个链表的长度,增加查找效率

HashMap本来是以空间换时间,所以填充比没必要太大。但是填充比太小又会导致空间浪费。如果关注内存,填充比可以稍大,如果主要关注查找性能,填充比可以稍小。

 1publicclass HashMapextends AbstractMapimplements Map, Cloneable, Serializable {  
 2privatestaticfinallong serialVersionUID = 362498820763181265L;  
 3staticfinalint DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16   4staticfinalint MAXIMUM_CAPACITY = 1 << 30;//最大容量   5staticfinalfloat DEFAULT_LOAD_FACTOR = f;//填充比  
 6//当add一个元素到某个位桶,其链表长度达到8时将链表转换为红黑树   7staticfinalint TREEIFY_THRESHOLD = 8;  
 8staticfinalint UNTREEIFY_THRESHOLD = 6;  
 9staticfinalint MIN_TREEIFY_CAPACITY = 64;  
10transient Node[] table;//存储元素的数组  11transient Set<map.entry> entrySet;  
12transientint size;//存放元素的个数  13transientint modCount;//被修改的次数fast-fail机制  14int threshold;//临界值 当实际大小(容量*填充比)超过临界值时,会进行扩容   15finalfloat loadFactor;//填充比(......后面略)

三,HashMap的构造函数

HashMap的构造方法有4种,主要涉及到的参数有,指定初始容量,指定填充比和用来初始化的Map

 1//构造函数1   2public HashMap(int initialCapacity, float loadFactor) {  
 3//指定的初始容量非负   4if (initialCapacity < 0)  
 5thrownew IllegalArgumentException(Illegal initial capacity:  +  
 6                                           initialCapacity);  
 7//如果指定的初始容量大于最大容量,置为最大容量   8if (initialCapacity > MAXIMUM_CAPACITY)  
 9         initialCapacity = MAXIMUM_CAPACITY;  
10//填充比为正  11if (loadFactor <= 0 || Float.isNaN(loadFactor))  
12thrownew IllegalArgumentException(Illegal load factor:  +  
13                                           loadFactor);  
14this.loadFactor = loadFactor;  
15this.threshold = tableSizeFor(initialCapacity);//新的扩容临界值  16}  
1718//构造函数2  19public HashMap(int initialCapacity) {  
20this(initialCapacity, DEFAULT_LOAD_FACTOR);  
21}  
2223//构造函数3  24public HashMap() {  
25this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted  26}  
2728//构造函数4用m的元素初始化散列映射  29public HashMap(Mapextends K, ? extends V--> m) {  
30this.loadFactor = DEFAULT_LOAD_FACTOR;  
31     putMapEntries(m, false);  
32 }

四,HashMap的存取机制

1,HashMap如何getValue值,看源码

 1public V get(Object key) {  
 2         Node e;  
 3return (e = getNode(hash(key), key)) == null ? null : e.value;  
 4    }  
 5/** 6     * Implements Map.get and related methods 
 7     * 
 8     * @param hash hash for key 
 9     * @param key the key 
10     * @return the node, or null if none 
11*/12final NodegetNode(int hash, Object key) {  
13         Node[] tab;//Entry对象数组  14     Nodefirst,e; //在tab数组中经过散列的第一个位置  15int n;  
16    K k;  
17/*找到插入的第一个Node,方法是hash值和n-1相与,tab[(n - 1) & hash]*/18//也就是说在一条链上的hash值相同的  19if ((tab = table) != null && (n = ) > 0 &&(first = tab[(n - 1) & hash]) != null) {  
20/*检查第一个Node是不是要找的Node*/21if (first.hash == hash && // always check first node  22                 ((k = ) == key || (key != null && (k))))//判断条件是hash值要相同,key值要相同  23return first;  
24/*检查first后面的node*/25if ((e = ) != null) {  
26if (first instanceof TreeNode)  
27return ((TreeNode)first).getTreeNode(hash, key);  
28/*遍历后面的链表,找到key值和hash值都相同的Node*/29do {  
30if (e.hash == hash &&  
31                         ((k = ) == key || (key != null && (k))))  
32return e;  
33                 } while ((e = ) != null);  
34            }  
35        }  
36returnnull;  
37     }

get(key)方法时获取key的hash值,计算hash&(n-1)得到在链表数组中的位置first=tab[hash&(n-1)],先判断first的key是否与参数key相等,不等就遍历后面的链表找到相同的key值返回对应的Value值即可

2,HashMap如何put(key,value);看源码

 1public V put(K key, V value) {  
 2return putVal(hash(key), key, value, false, true);  
 3    }  
 4/** 5     * Implements Map.put and related methods 
 6     * 
 7     * @param hash hash for key 
 8     * @param key the key 
 9     * @param value the value to put 
10     * @param onlyIfAbsent if true, don't change existing value 
11     * @param evict if false, the table is in creation mode. 
12     * @return previous value, or null if none 
13*/14final V putVal(int hash, K key, V value, boolean onlyIfAbsent,  
15boolean evict) {  
16         Node[] tab;   
17     Node p;   
18int n, i;  
19if ((tab = table) == null || (n = ) == 0)  
20             n = (tab = resize()).length;  
21/*如果table的在(n-1)&hash的值是空,就新建一个节点插入在该位置*/22if ((p = tab[i = (n - 1) & hash]) == null)  
23             tab[i] = newNode(hash, key, value, null);  
24/*表示有冲突,开始处理冲突*/25else {  
26             Node e;   
27        K k;  
28/*检查第一个Node,p是不是要找的值*/29if (p.hash == hash &&((k = ) == key || (key != null && (k))))  
30                 e = p;  
31elseif (p instanceof TreeNode)  
32                 e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);  
33else {  
34for (int binCount = 0; ; ++binCount) {  
35/*指针为空就挂在后面*/36if ((e = ) == null) {  
37                          = newNode(hash, key, value, null);  
38//如果冲突的节点数已经达到8个,看是否需要改变冲突节点的存储结构,               
39             //treeifyBin首先判断当前hashMap的长度,如果不足64,只进行  
40//resize,扩容table,如果达到64,那么将冲突的存储结构为红黑树  41if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  42                            treeifyBin(tab, hash);  
43break;  
44                    }  
45/*如果有相同的key值就结束遍历*/46if (e.hash == hash &&((k = ) == key || (key != null && (k))))  
47break;  
48                     p = e;  
49                }  
50            }  
51/*就是链表上有相同的key值*/52if (e != null) { // existing mapping for key,就是key的Value存在  53                 V oldValue = e.value;  
54if (!onlyIfAbsent || oldValue == null)  
55                     e.value = value;  
56                afterNodeAccess(e);  
57return oldValue;//返回存在的Value值  58            }  
59        }  
60         ++modCount;  
61/*如果当前大小大于门限,门限原本是初始容量**/62if (++size > threshold)  
63             resize();//扩容两倍  64        afterNodeInsertion(evict);  
65returnnull;  
66     }

下面简单说下添加键值对put(key,value)的过程:
1,判断键值对数组tab[]是否为空或为null,否则以默认大小resize();
2,根据键值key计算hash值得到插入的数组索引i,如果tab[i]==null,直接新建节点添加,否则转入3
3,判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理

五,HasMap的扩容机制resize();

构造hash表时,如果不指明初始大小,默认大小为16(即Node数组大小16),如果Node[]数组中的元素达到(填充比*)重新调整HashMap大小 变为原来2倍大小,扩容很耗时

 1/** 2    * Initializes or doubles table size.  If null, allocates in 
 3    * accord with initial capacity target held in field threshold. 
 4    * Otherwise, because we are using power-of-two expansion, the 
 5    * elements from each bin must either stay at same index, or move 
 6    * with a power of two offset in the new table. 
 7    * 
 8    * @return the table 
 9*/10final Node[] resize() {  
11        Node[] oldTab = table;  
12int oldCap = (oldTab == null) ? 0 : oldTab.length;  
13int oldThr = threshold;  
14int newCap, newThr = 0;  
1516/*如果旧表的长度不是空*/17if (oldCap > 0) {  
18if (oldCap >= MAXIMUM_CAPACITY) {  
19                threshold = ;  
20return oldTab;  
21           }  
22/*把新表的长度设置为旧表长度的两倍,newCap=2*oldCap*/23elseif ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&  
24                     oldCap >= DEFAULT_INITIAL_CAPACITY)  
25/*把新表的门限设置为旧表门限的两倍,newThr=oldThr*2*/26                newThr = oldThr << 1; // double threshold  27       }  
28/*如果旧表的长度的是0,就是说第一次初始化表*/29elseif (oldThr > 0) // initial capacity was placed in threshold  30            newCap = oldThr;  
31else {               // zero initial threshold signifies using defaults  32            newCap = DEFAULT_INITIAL_CAPACITY;  
33            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);  
34       }  
35363738if (newThr == 0) {  
39float ft = (float)newCap * loadFactor;//新表长度乘以加载因子  40            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?  
41                      (int)ft : );  
42       }  
43        threshold = newThr;  
44        @SuppressWarnings({"rawtypes","unchecked"})  
45/*下面开始构造新表,初始化表中的数据*/46        Node[] newTab = (Node[])new Node[newCap];  
47        table = newTab;//把新表赋值给table  48if (oldTab != null) {//原表不是空要把原表中数据移动到新表中      49/*遍历原来的旧表*/50for (int j = 0; j < oldCap; ++j) {  
51                Node e;  
52if ((e = oldTab[j]) != null) {  
53                    oldTab[j] = null;  
54if ( == null)//说明这个node没有链表直接放在新表的e.hash & (newCap - 1)位置  55                        newTab[e.hash & (newCap - 1)] = e;  
56elseif (e instanceof TreeNode)  
57                        ((TreeNode)e).split(this, newTab, j, oldCap);  
58/*如果e后边有链表,到这里表示e后面带着个单链表,需要遍历单链表,将每个结点重*/59else { // preserve order保证顺序  60////新计算在新表的位置,并进行搬运  61                        NodeloHead = null, loTail = null;  
62                        NodehiHead = null, hiTail = null;  
63                        Node next;  
6465do {  
66                            next = ;//记录下一个结点  
67//新表是旧表的两倍容量,实例上就把单链表拆分为两队,  
68              //oldCap为偶数一队,oldCap为奇数一对  69if ((e.hash & oldCap) == 0) {  
70if (loTail == null)  
71                                    loHead = e;  
72else73                                    loTail.next = e;  
74                                loTail = e;  
75                           }  
76else {  
77if (hiTail == null)  
78                                    hiHead = e;  
79else80                                    hiTail.next = e;  
81                                hiTail = e;  
82                           }  
83                        } while ((e = next) != null);  
8485if (loTail != null) {//lo队不为null,放在新表原位置  86                            loTail.next = null;  
87                            newTab[j] = loHead;  
88                       }  
89if (hiTail != null) {//hi队不为null,放在新表j+oldCap位置  90                            hiTail.next = null;  
91                            newTab[j + oldCap] = hiHead;  
92                       }  
93                   }  
94               }  
95           }  
96       }  
97return newTab;  
98    }


六,使用红黑树的改进

在Java jdk8中对HashMap的源码进行了优化,在jdk7中,HashMap处理“碰撞”的时候,都是采用链表来存储,当碰撞的结点很多时,查询时间是O(n)。
在jdk8中,HashMap处理“碰撞”增加了红黑树这种数据结构,当碰撞结点较少时,采用链表存储,当较大时(>8个),采用红黑树(特点是查询时间是O(logn))存储(有一个阀值控制,大于阀值(8个),将链表存储转换成红黑树存储)

问题分析:

你可能还知道哈希碰撞会对hashMap的性能带来灾难性的影响。如果多个hashCode()的值落到同一个桶内的时候,这些值是存储到一个链表中的。最坏的情况下,所有的key都映射到同一个桶中,这样hashmap就退化成了一个链表——查找时间从O(1)到O(n)。

随着HashMap的大小的增长,get()方法的开销也越来越大。由于所有的记录都在同一个桶里的超长链表内,平均查询一条记录就需要遍历一半的列表。

HashMap的红黑树是这样解决的

         如果某个桶中的记录过大的话(当前是TREEIFY_THRESHOLD = 8),HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好,是O(logn),而不是糟糕的O(n)。

        它是如何工作的?前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面,这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树,使用哈希值作为树的分支变量,如果两个哈希值不等,但指向同一个桶的话,较大的那个会插入到右子树里。如果哈希值相等,HashMap希望key值最好是实现了Comparable接口的,这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的,不过如果实现了当然最好。如果没有实现这个接口,在出现严重的哈希碰撞的时候,你就并别指望能获得性能提升了。

上一篇:微企点是什么?微企点的作用 下一篇:没有了

新闻资讯