java 8 Hashmap深入解析 —— put get 方法源码

转载 2017年08月28日 20:17:40

  每个java程序员都知道,HashMap是java中最重要的集合类之一,也是找工作面试中非常常见的考点,因为HashMap的实现本身确实蕴含了很多精妙的代码设计。

  对于普通的程序员,可能仅仅能说出HashMap线程不安全,允许key、value为null,以及不要求线程安全时,效率上比HashTable要快一些。稍微好一些的,会对具体实现有过大概了解,能说出HashMap由数组+链表+RBT实现,并了解HashMap的扩容机制。但如果你真的有一个刨根问题的热情,那么你肯定会想知道具体是如何一步步实现的。HashMap的源码一共2000多行,很难在这里每一句都说明,但这篇文章会让你透彻的理解到我们平时常用的几个操作下,HashMap是如何工作的。

   要先提一下的是,我看过很多讲解HashMap原理的文章,有一些讲的非常好,但这些文章习惯于把源代码和逻辑分析分开,导致出现了大段的文字讲解代码,阅读起来有些吃力和枯燥。所以我想尝试另一种风格,将更多的内容写进注释里,可能看起来有些啰嗦,但对于一些新手的理解,应该会有好的效果。


 

  • HashMap结构

   首先是了解HashMap的几个核心成员变量(以下均为jdk源码):

复制代码
 1   transient Node<K,V>[] table;        //HashMap的哈希桶数组,非常重要的存储结构,用于存放表示键值对数据的Node元素。
 2 
 3   transient Set<Map.Entry<K,V>> entrySet;  //HashMap将数据转换成set的另一种存储形式,这个变量主要用于迭代功能。
 4 
 5   transient int size;             //HashMap中实际存在的Node数量,注意这个数量不等于table的长度,甚至可能大于它,因为在table的每个节点上是一个链表(或RBT)结构,可能不止有一个Node元素存在。
 6 
 7   transient int modCount;           //HashMap的数据被修改的次数,这个变量用于迭代过程中的Fail-Fast机制,其存在的意义在于保证发生了线程安全问题时,能及时的发现(操作前备份的count和当前modCount不相等)并抛出异常终止操作。
 8 
 9   int threshold;                //HashMap的扩容阈值,在HashMap中存储的Node键值对超过这个数量时,自动扩容容量为原来的二倍。
10 
11   final float loadFactor;           //HashMap的负载因子,可计算出当前table长度下的扩容阈值:threshold = loadFactor * table.length。 
复制代码

 

  显然,HashMap的底层实现是基于一个Node的数组,那么Node是什么呢?在HashMap的内部可以看见定义了这样一个内部类:

复制代码
 1 static class Node<K,V> implements Map.Entry<K,V> {
 2   final int hash;
 3   final K key;
 4     V value;
 5     Node<K,V> next;
 6 
 7     Node(int hash, K key, V value, Node<K,V> next) {
 8         this.hash = hash;
 9         this.key = key;
10         this.value = value;
11         this.next = next;
12     }
13 
14     public final K getKey()        { return key; }
15     public final V getValue()      { return value; }
16     public final String toString() { return key + "=" + value; }
17 
18     public final int hashCode() {
19         return Objects.hashCode(key) ^ Objects.hashCode(value);
20     }
21 
22     public final V setValue(V newValue) {
23         V oldValue = value;
24         value = newValue;
25         return oldValue;
26     }
27 
28     public final boolean equals(Object o) {
29         if (o == this)
30             return true;
31         if (o instanceof Map.Entry) {
32             Map.Entry<?,?> e = (Map.Entry<?,?>)o;
33             if (Objects.equals(key, e.getKey()) &&
34                 Objects.equals(value, e.getValue()))
35                 return true;
36         }
37         return false;
38     }
39 }
复制代码

 

  我们大体看一下这个内部类就可以知道,它实现了Map.Entry接口。其内部的变量含义也很明确,hash值、key\value对和实现链表和红黑树所需要的指针索引。

  既然知道了HashMap的基本结构,那么这些变量的默认值都是多少呢?我们再看一下HashMap定义的一些常量:

复制代码
 1     //默认的初始容量为16,必须是2的幂次
 2        static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
 3 
 4        //最大容量即2的30次方
 5        static final int MAXIMUM_CAPACITY = 1 << 30;
 6 
 7        //默认加载因子
 8        static final float DEFAULT_LOAD_FACTOR = 0.75f;
 9 
10        //当put一个元素时,其链表长度达到8时将链表转换为红黑树
11        static final int TREEIFY_THRESHOLD = 8;
12 
13        //链表长度小于6时,解散红黑树
14        static final int UNTREEIFY_THRESHOLD = 6;
15 
16        //默认的最小的扩容量64,为避免重新扩容冲突,至少为4 * TREEIFY_THRESHOLD=32,即默认初始容量的2倍
17        static final int MIN_TREEIFY_CAPACITY = 64;
复制代码

 

  • TIP : 在HashMap内部定义的几个变量,包括桶数组本身都是transient修饰的,这代表了他们无法被序列化,而HashMap本身是实现了Serializable接口的。这很容易产生疑惑:HashMap是如何序列化的呢?查了一下源码发现,HashMap内有两个用于序列化的函数 readObject(ObjectInputStream s) 和 writeObject(ObjectOutputStreams),通过这个函数将table序列化。

  •  HashMap 的 put 方法解析

  以上就是我们对HashMap的初步认识,下面进入正题,看看HashMap是如何添加、查找与删除数据的。

  首先来看put方法,我尽量在每行都加注释阐明这一行的含义,让阅读起来更容易理解。

复制代码
 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,          //这里onlyIfAbsent表示只有在该key对应原来的value为null的时候才插入,也就是说如果value之前存在了,就不会被新put的元素覆盖。
 6                    boolean evict) {                                              //evict参数用于LinkedHashMap中的尾部操作,这里没有实际意义。
 7         Node<K,V>[] tab; Node<K,V> p; int n, i;                    //定义变量tab是将要操作的Node数组引用,p表示tab上的某Node节点,n为tab的长度,i为tab的下标。
 8         if ((tab = table) == null || (n = tab.length) == 0)                    //判断当table为null或者tab的长度为0时,即table尚未初始化,此时通过resize()方法得到初始化的table。                        
 9             n = (tab = resize()).length;                        //这种情况是可能发生的,HashMap的注释中提到:The table, initialized on first use, and resized as necessary。
10         if ((p = tab[i = (n - 1) & hash]) == null)                               //此处通过(n - 1) & hash 计算出的值作为tab的下标i,并另p表示tab[i],也就是该链表第一个节点的位置。并判断p是否为null。
11             tab[i] = newNode(hash, key, value, null);                 //当p为null时,表明tab[i]上没有任何元素,那么接下来就new第一个Node节点,调用newNode方法返回新节点赋值给tab[i]。
12         else {                                              //下面进入p不为null的情况,有三种情况:p为链表节点;p为红黑树节点;p是链表节点但长度为临界长度TREEIFY_THRESHOLD,再插入任何元素就要变成红黑树了。
13             Node<K,V> e; K k;                               //定义e引用即将插入的Node节点,并且下文可以看出 k = p.key。
14             if (p.hash == hash &&                             //HashMap中判断key相同的条件是key的hash相同,并且符合equals方法。这里判断了p.key是否和插入的key相等,如果相等,则将p的引用赋给e。
15                 ((k = p.key) == key || (key != null && key.equals(k))))           //这一步的判断其实是属于一种特殊情况,即HashMap中已经存在了key,于是插入操作就不需要了,只要把原来的value覆盖就可以了。
16                 e = p;                                    //这里为什么要把p赋值给e,而不是直接覆盖原值呢?答案很简单,现在我们只判断了第一个节点,后面还可能出现key相同,所以需要在最后一并处理。
17             else if (p instanceof TreeNode)                                       //现在开始了第一种情况,p是红黑树节点,那么肯定插入后仍然是红黑树节点,所以我们直接强制转型p后调用TreeNode.putTreeVal方法,返回的引用赋给e。
18                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);   //你可能好奇,这里怎么不遍历tree看看有没有key相同的节点呢?其实,putTreeVal内部进行了遍历,存在相同hash时返回被覆盖的TreeNode,否则返回null。
19             else {                                                  //接下里就是p为链表节点的情形,也就是上述说的另外两类情况:插入后还是链表/插入后转红黑树。另外,上行转型代码也说明了TreeNode是Node的一个子类。
20                 for (int binCount = 0; ; ++binCount) {                 //我们需要一个计数器来计算当前链表的元素个数,并遍历链表,binCount就是这个计数器。
21                     if ((e = p.next) == null) {                     //遍历过程中当发现p.next为null时,说明链表到头了,直接在p的后面插入新的链表节点,即把新节点的引用赋给p.next,插入操作就完成了。注意此时e赋给p。
22                         p.next = newNode(hash, key, value, null);          //最后一个参数为新节点的next,这里传入null,保证了新节点继续为该链表的末端。
23                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st     //插入成功后,要判断是否需要转换为红黑树,因为插入后链表长度加1,而binCount并不包含新节点,所以判断时要将临界阈值减1。
24                             treeifyBin(tab, hash);                     //当新长度满足转换条件时,调用treeifyBin方法,将该链表转换为红黑树。
25                         break;                                //当然如果不满足转换条件,那么插入数据后结构也无需变动,所有插入操作也到此结束了,break退出即可。
26                     }
27                     if (e.hash == hash &&                         //在遍历链表的过程中,我之前提到了,有可能遍历到与插入的key相同的节点,此时只要将这个节点引用赋值给e,最后通过e去把新的value覆盖掉就可以了。
28                         ((k = e.key) == key || (key != null && key.equals(k))))   //老样子判断当前遍历的节点的key是否相同。
29                         break;                                //找到了相同key的节点,那么插入操作也不需要了,直接break退出循环进行最后的value覆盖操作。
30                     p = e;                                  //在第21行我提到过,e是当前遍历的节点p的下一个节点,p = e 就是依次遍历链表的核心语句。每次循环时p都是下一个node节点。
31                 }
32             }
33             if (e != null) { // existing mapping for key                //左边注释为jdk自带注释,说的很明白了,针对已经存在key的情况做处理。
34                 V oldValue = e.value;                           //定义oldValue,即原存在的节点e的value值。
35                 if (!onlyIfAbsent || oldValue == null)                 //前面提到,onlyIfAbsent表示存在key相同时不做覆盖处理,这里作为判断条件,可以看出当onlyIfAbsent为false或者oldValue为null时,进行覆盖操作。
36                     e.value = value;                              //覆盖操作,将原节点e上的value设置为插入的新value。
37                 afterNodeAccess(e);                            //这个函数在hashmap中没有任何操作,是个空函数,他存在主要是为了linkedHashMap的一些后续处理工作。
38                 return oldValue;                              //这里很有意思,他返回的是被覆盖的oldValue。我们在使用put方法时很少用他的返回值,甚至忘了它的存在,这里我们知道,他返回的是被覆盖的oldValue。
39             }
40         }                                            
41         ++modCount;                                      //收尾工作,值得一提的是,对key相同而覆盖oldValue的情况,在前面已经return,不会执行这里,所以那一类情况不算数据结构变化,并不改变modCount值。
42         if (++size > threshold)                               //同理,覆盖oldValue时显然没有新元素添加,除此之外都新增了一个元素,这里++size并与threshold判断是否达到了扩容标准。
43             resize();                                     //当HashMap中存在的node节点大于threshold时,hashmap进行扩容。
44         afterNodeInsertion(evict);                             //这里与前面的afterNodeAccess同理,是用于linkedHashMap的尾部操作,HashMap中并无实际意义。1
45         return null;                                        //最终,对于真正进行插入元素的情况,put函数一律返回null。
46     }
复制代码

    在上述代码中的第十行,HashMap根据 (n - 1) & hash 求出了元素在node数组的下标。这个操作非常精妙,下面我们仔细分析一下计算下标的过程,主要分三个阶段:计算hashcode、高位运算和取模运算。

  首先,传进来的hash值是由put方法中的hash(key)产生的(上述第2行),我们来看一下hash()方法的源码:

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

  这里通过key.hashCode()计算出key的哈希值,然后将哈希值h右移16位,再与原来的h做异或^运算——这一步是高位运算。设想一下,如果没有高位运算,那么hash值将是一个int型的32位数。而从2的-31次幂到2的31次幂之间,有将近几十亿的空间,如果我们的HashMap的table有这么长,内存早就爆了。所以这个散列值不能直接用来最终的取模运算,而需要先加入高位运算,将高16位和低16位的信息"融合"到一起,也称为"扰动函数"。这样才能保证hash值所有位的数值特征都保存下来而没有遗漏,从而使映射结果尽可能的松散。最后,根据 n-1 做与操作的取模运算。这里也能看出为什么HashMap要限制table的长度为2的n次幂,因为这样,n-1可以保证二进制展示形式是(以16为例)0000 0000 0000 0000 0000 0000 0000 1111。在做"与"操作时,就等同于截取hash二进制值得后四位数据作为下标。这里也可以看出"扰动函数"的重要性了,如果高位不参与运算,那么高16位的hash特征几乎永远得不到展现,发生hash碰撞的几率就会增大,从而影响性能。

  HashMap的put方法的源码实现就是这样了,整理思路非常连贯。这里面有几个函数的源码(比如resize、putTreeValue、newNode、treeifyBin)限于篇幅原因,就不贴了,后面应该还会更新在其他博客里,有兴趣的同学也可以自己挖掘一下。


  • HashMap 的 get 方法解析

   读完了put的源码,其实已经可以很清晰的理清HashMap的工作原理了。接下来再看get方法的源码,就非常的简单:

复制代码
 1     public V get(Object key) {
 2         Node<K,V> e;
 3         return (e = getNode(hash(key), key)) == null ? null : e.value;      //根据key及其hash值查询node节点,如果存在,则返回该节点的value值。
 4     }
 5 
 6     final Node<K,V> getNode(int hash, Object key) {                  //根据key搜索节点的方法。记住判断key相等的条件:hash值相同 并且 符合equals方法。
 7         Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
 8         if ((tab = table) != null && (n = tab.length) > 0 &&            //根据输入的hash值,可以直接计算出对应的下标(n - 1)& hash,缩小查询范围,如果存在结果,则必定在table的这个位置上。
 9             (first = tab[(n - 1) & hash]) != null) {
10             if (first.hash == hash && // always check first node
11                 ((k = first.key) == key || (key != null && key.equals(k))))    //判断第一个存在的节点的key是否和查询的key相等。如果相等,直接返回该节点。
12                 return first;
13             if ((e = first.next) != null) {                       //遍历该链表/红黑树直到next为null。
14                 if (first instanceof TreeNode)                       //当这个table节点上存储的是红黑树结构时,在根节点first上调用getTreeNode方法,在内部遍历红黑树节点,查看是否有匹配的TreeNode。
15                     return ((TreeNode<K,V>)first).getTreeNode(hash, key);
16                 do {
17                     if (e.hash == hash &&                        //当这个table节点上存储的是链表结构时,用跟第11行同样的方式去判断key是否相同。
18                         ((k = e.key) == key || (key != null && key.equals(k))))
19                         return e;
20                 } while ((e = e.next) != null);                      //如果key不同,一直遍历下去直到链表尽头,e.next == null。
21             }
22         }
23         return null;
24     }
复制代码

  因为查询过程不涉及到HashMap的结构变动,所以get方法的源码显得很简洁。核心逻辑就是遍历table某特定位置上的所有节点,分别与key进行比较看是否相等。


  以上便是HashMap最常用API的源码分析,除此之外,HashMap还有一些知识需要重点学习:扩容机制、并发安全问题、内部红黑树的实现。这些内容我也会在之后陆续发文分析,希望可以帮读者彻底理解HashMap的原理。

原文地址:http://www.cnblogs.com/jzb-blog/p/6637823.html


相关文章推荐

JDK源码之解读hashMap 的put和get方法的实现原理

JDK源码之解读hashMap 的put和get方法的实现原理 1,put              对于方法hashmap.put(K,V),首先是把k处理,通过hashcode方法处理...

HashMap中的数据结构与get,put源码解析

HashMap 执行流程:   首先构造方法: public HashMap() {         this.loadFactor = DEFAULT_LOAD_FACTOR; // all oth...

Java 1.8 HashMap 源码中 put()方法详解

在jdk1.7的时候,hashmap底层结构就是数组+链表的结构,如果发生冲突,即hashcode相同key也相同,但是value不同的话,那么就会放在底层数组的同一个下标处,官方话叫同一个桶内,以链...

Java HashMap的数据结构以及put和get方法

1 HashMap的数据结构 HashMap实际上是一个链表数组,也就是最外层是数组,数组的元素是链表。    2 HashMap的put方法: 源代码如下:   public V put(K ...

HashMap源码注解 之 put()方法(六)

注意 , 本文基于JDK 1.8 HashMap#put() /** * Associates the specified value with the specified key...

HashMap的put源码解析

put方法的源码如下:public V put(K key, V value) { return putVal(hash(key), key, value, false, true);...

Java 8集合框架源码学习——HashMap

心得:相较于JDK 1.7,Java 8中的HashMap有了较大的性能提升。修改了hash和resize方式,增加了红黑树的支持。学习参考资料: (1)疫苗:Java HashMap的死循环;1....

HashMap的put和get方法原理

概述JAVA中的数组,在添加或者删除元素的时候,都会复制一个新数组,比较耗内存。但是数组的遍历则是非常高效的。链表则是相反, 遍历慢(需要遍历数组,一直找到值相等的元素才算找到),而添加和删除元素代...

HashMap原理及put与get方法调用过程

HashMap的原理 HashMap的数据结构为数组+链表,以key,value的形式存值,通过调用put与get方法来存值与取值。 它内部维护了一个Entry数组,得到key的hashCode值...

HashMap的put、get方法分析与Hash冲突的分析、解决

HashMap的put、get方法分析与Hash冲突的分析、解决
  • dch9210
  • dch9210
  • 2016年09月26日 23:40
  • 1477
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java 8 Hashmap深入解析 —— put get 方法源码
举报原因:
原因补充:

(最多只允许输入30个字)