HashMap实现原理和源码详细分析

薄荷少年衬衣情

HashMap完成道理战源码详细阐发

ps：本专客基于Jdk1.8

  进修要面：
1、明白HashMap的数据构造
2、理解HashMap中的集列算法
3、明白HashMap中put、remove、get的代码完成
4、HashMap的哈希抵触是甚么？怎样处置的？
5、明白HashMap的扩容机造

1、甚么是HashMap？

HashMap 基于哈希表的 Map 接话柄现，是以 key-value 存储情势存正在 ，HashMap 的完成没有是同步的，那意味着它没有是线程宁静的。它的 key、value 皆能够为 null，别的，HashMap 中的映照没有是有序的。
2、HashMap的特征

• Hash存储无序的
  
• key战value皆能够存储null值，可是key只能存独一的一个null值
  
• jdk8之前的数据构造是数组+链表，Jdk8以后酿成数组+链表+白乌树
  
• 阀值年夜于8而且数组少度年夜于64才会转为白乌树
  

3、HashMap的数据构造

JDK7的状况，是数组减链接，hash抵触时分，便转换为链表：

jdk8的状况，jdk8减上了白乌树，链表的数量年夜于8并且数组少度年夜于64以后，便转换为白乌树，白乌树节面小于6以后，便又转换为链表：

翻下HashMap源码，对应的节面疑息：

1. static class Node<K,V> implements Map.Entry<K,V> {
2.         // hashCode
3.         final int hash;
4.         final K key;
5.         V value;
6.         // 链表的next指针便没有为null
7.         Node<K,V> next;
9.         Node(int hash, K key, V value, Node<K,V> next) {
10.             this.hash = hash;
11.             this.key = key;
12.             this.value = value;
13.             this.next = next;
14.         }
15.         // ...
16. }        

复造代码

4、HashMap初初化操作

4.1、成员变量

1. public class HashMap<K,V> extends AbstractMap<K,V>
2.     implements Map<K,V>, Cloneable, Serializable {
3.         /**
4.      * 序列号版本号
5.      */
6.     private static final long serialVersionUID = 362498820763181265L;
8.    /**
9.      * 初初化容量，为16=2的4次幂
10.      */
11.     static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
13.    /**
14.      * 最年夜容量，为2的30次幂
15.      */
16.     static final int MAXIMUM_CAPACITY = 1 << 30;
18.     /**
19.      * 默许的背载果子，默许值是0.75
20.      */
21.     static final float DEFAULT_LOAD_FACTOR = 0.75f;
23.     /**
24.      * 链表节面树超越8便转为为白乌树
25.      */
26.     static final int TREEIFY_THRESHOLD = 8;
27.    
28.     /**
29.      * 白乌树节面少于6便再转换回链表
30.      */
31.     static final int UNTREEIFY_THRESHOLD = 6;
32.    
33.     /**
34.      * 桶中构造转化为白乌树对应的数组少度最小的值
35.      */
36.     static final int MIN_TREEIFY_CAPACITY = 64;
37.    
38.     // ...
39.        
40.          /**
41.      * HashMap存储元素的数组
42.      */
43.         transient Node<K,V>[] table;
45.     /**
46.      * 用去寄存缓存
47.      */
48.     transient Set<Map.Entry<K,V>> entrySet;
50.     /**
51.      * HashMap寄存元素的个数
52.      */
53.     transient int size;
55.     /**
56.      * 用去记载HashMap的修正次数
57.      */
58.     transient int modCount;
60.     /**
61.      * 用去调解巨细下一个容量的值（容量*背载果子）
62.      */
63.     int threshold;
65.     /**
66.      * Hash表的背载果子
67.      */
68.     final float loadFactor;
70. }   

复造代码

h4a id="42__124"/a4.2、 机关办法/h4

1. public HashMap(int initialCapacity, float loadFactor) {
2.     // 初初容量不克不及小于0，小于0间接扔出IllegalArgumentException
3.     if (initialCapacity < 0)
4.         throw new IllegalArgumentException("Illegal initial capacity: " +
5.                                            initialCapacity);
6.      // 初初容量年夜于最年夜容量的时分，与最年夜容量做为初初容量
7.     if (initialCapacity > MAXIMUM_CAPACITY)
8.         initialCapacity = MAXIMUM_CAPACITY;
9.      // 背载果子不克不及小于0，并且如果数值范例，isNan:true,暗示便长短数值范例
10.     if (loadFactor <= 0 || Float.isNaN(loadFactor))
11.         throw new IllegalArgumentException("Illegal load factor: " +
12.                                            loadFactor);
13.     // 将指定的背载果子赋值给齐局变量
14.     this.loadFactor = loadFactor;
15.     // threshold  = (容量) * (背载果子)
16.     this.threshold = tableSizeFor(initialCapacity);
17. }
20. public HashMap(int initialCapacity) {
21.      // 初初化容量战默许背载果子
22.     this(initialCapacity, DEFAULT_LOAD_FACTOR);
23. }
24. public HashMap() {
25.     // 默许的背载果子为0.75
26.         this.loadFactor = DEFAULT_LOAD_FACTOR;
27. }

复造代码

p然后，我们明白HashMap的默许容量是16，然后是正在那里赋值的？从上里那个代码就能够明白codethis.threshold = tableSizeFor(initialCapacity);/code/p

1. static final int tableSizeFor(int cap) {
2.     int n = cap - 1;
3.     n |= n >>> 1;
4.     n |= n >>> 2;
5.     n |= n >>> 4;
6.     n |= n >>> 8;
7.     n |= n >>> 16;
8.     return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
9. }

复造代码

那里触及到计较机根本常识的，左移运算战或运算，上面给出图例：经由过程比较贫困的计较得出n为16

往代码里翻，借找到上面那个机关办法public HashMap(Map