HashMap源码追踪

一、哈希表

1、在JDK中的代表有：Hashtable，HashMap，ConcurrentHashMap等

2、Hashtable：数组+链表，线程安全

如果一个线程在给Hashtable中添加/删除元素，就会遇到“同步”，其他线程等待。

3、HashMap：线程不安全，并发时可能出现死循环等问题

JDK1.7及之前：数组+链表

JDK1.8：数组+链表/红黑树

4、ConcurrentHashMap：线程安全的，

JDK1.7及之前：区段+数组+链表，把数组分为几个区段，锁的是区段

JDK1.8：数组+链表/红黑树，锁的是table[index]

二、hash冲突：

（1）两个对象的hashCode完全一致，例如：Aa和BB，这种概率相对低

（2）两个对象的hashCode不一样，但是hashCode值（int） ==> hash值（int）加工后的结果一样，这种概率也比较低

（3）加工后的hash值不同，但是hash值 & table.length-1 结果一致

后（2）和（3）是因为数组的长度有限导致。

三、JDK1.7及之前的HashMap

1、底层实现

数组+链表

2、为什么要用数组？为什么又要结合链表？

数组的优点：

可以根据[index]快速的定位到某个元素的位置

理论上，假设内存足够大，数组也可以足够大，我可以让每一个对象单独存储到数组的某个[index],用它们的hashCode值作为下标。

但是实际中（1）内存不是无限的（2）hashCode值可能重复（不同的对象，hashCode还可能相同），会出现hash冲突问题。

这个时候，我们可以用数组+链表来存储。

链表的优点：

无限延长

链表解决的就是当两个对象hash冲突时，在table[index]下面用链表的结构表示多个元素。

3、直接用hashCode做下标呢？还是要对hashCode值进行加工呢？为什么？

需要加工。

hashCode的值范围太大了，例如：某个对象的hashCode值是23546，意味着你的数组需要一个下标[23546]，这样对数组的长度要求太大了。

4、如何加工hashCode值？或者问 hashCode 与 数组的下标如何对应？

（1）第一步：hashCode值经过一个hash算法进行干扰，目的是希望能够尽量的打散我们的元素存储

hashCode值（int） ==> hash值（int）

（2）第二步：用hash值 与 table.length做一个运算，保证在[0, table.length-1]范围内

思路1： hash值 % table.length 结果在在[0, table.length-1]范围内

思路2： hash值 & table.length-1 要求table.length必须是2的n次方

table.length-1的二进制是一个前面都是0，后几位全是1的

数组的长度为8，长度-1是7, 7的二进制是111

其他值：xxxxxxxxxxxx

长度-1: 000000000111

&的结果：000000000000

&的结果：000000000001

&的结果：000000000010

&的结果：000000000100

&的结果：000000000011

&的结果：000000000101

&的结果：000000000110

&的结果：000000000111

注意：源码中的哈希表的底层的数组的长度一定是2的n次方，如果你手动指定一个长度，它不是2的n次方，内部依然会给你纠正为2的n次方

5、了解几个常量和变量

查看源码：shift(2) java.HashMap(classes)

ctrl+F12查看类中方法

• 初始化容量

int DEFAULT_INITIAL_CAPACITY = 1 << 4;//16

• 默认加载因子

float DEFAULT_LOAD_FACTOR = 0.75f;

final float loadFactor;手动指定的加载因子，如果没有指定，初始化为DEFAULT_LOAD_FACTOR，一旦指定就不能修改了。

数组的默认初始化容量是16，如果数组的长度一直是16，那么随着元素数量的增多，导致冲突越来越严重，table[index]的链表会很长，

很长，意味着添加、删除、查询的效率就降低了。这个时候就考虑数组可能需要“扩容”。

当满足xxx条件时，我们要扩容。其中一个条件就是 size >= table.length * 0.75 就可能扩容

6、不使用0.75，手动指定这个值，指定为0.1，或1，或者其他，有什么影响？

0.1：扩容的频率增加，浪费的空间多

1：扩容的频率降低，链表就会加长

0.75这个值，是数学家们算出来的某个比较优秀的临近点。

int threshold; 阈值

threshold = table.length * loadFactor;

四、跟踪：JDK1.7的HashMap的源码

1、new HashMap<>()

public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; }

追踪this

非法校验 this.loadFactor = loadFactor; //0.75 threshold = initialCapacity; //16

2、put(key,value)

一开始table是初始化为一个EMPTY_TABLE，长度为0，类型Entry<K,V>[]

① 先判断table是否是EMPTY_TABLE

如果是，说明没有添加过元素，table长度为0

如果table是EMPTY_TABLE时，做了如下事情：注意如果指定的长度不是2的n次方，会纠正，Integer.highestOneBit((number - 1) << 1)（使传入的number变为2的n次方）

table = new Entry[16]; threshold = capacity * loadFactor = 16 * 0.75 = 12;

②key == null，单独处理，并结束

putForNullKey(value); addEntry(int Hash,K key,V value,int bucketIndex);

1）先检查table[0]下面是否有另一个key为null的Entry（称为key重复），如果有，把新的value替换了旧的value(覆盖)。结束。

2）如果没有“key重复”，尝试把（key,value)添加到table[0]中先检查是否需要扩容，if(size >= threshold && table[0] != null)就扩容为原来的2倍

key为null的hash是0.

index为0

3创建了一个新的Entry对象，并且把原来table[0]下面的链表连接到我新的Entry对象的next中，即新的Entry对象是table[0]下面的链表的新的head。

4）size++

③key不为null

1）对key的hashCode值进行加工，用了hash()函数

2）用加工后的hash 和table.length-1做了一个&运算，得到一个index，可能是[0, table.length-1]范围内的任意一个值

3）先检查table[index]下面是否有Entry的key与我新添加的(key,value)的key“重复”

判断hash和key地址或key的equals方法，如果相同，说明“重复”，如果重复，就用新的value替换旧的value，结束

4）如果没有重复的key，尝试把（key,value)添加到table[index]中

先检查是否需要扩容，if(size >= threshold && table[index] != null)就扩容为原来的2倍

key不为null的hash重新加工

index为重新算，因为table.length变了

5）创建了一个新的Entry对象，并且把原来table[index]下面的链表连接到我新的Entry对象的next中，

即新的Entry对象是table[index]下面的链表的新的head。

6）size++

3、JDK1.7数组什么时候扩容，扩容为多少？

if(size >= threshold && table[index]!=null)

扩容为原来的2倍

4、下标怎么计算？

key为null，一定是0
key不为null， 加工后hash值 & table.length-1 得到下标，范围[0, table.length-1]

5、新加入table[index]下的Entry是作为链表的头还是尾？

作为头

五、JDK1.8之后的HashMap

1、几个常量和变量

int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 默认的初始化容量16
int MAXIMUM_CAPACITY = 1 << 30; 最大容量限制
float DEFAULT_LOAD_FACTOR = 0.75f; 默认加载因子 0.75
int TREEIFY_THRESHOLD = 8; 树化阈值

2、为什么JDK1.8要引入树（红黑树），不单用链表了？

因为链表如果长了，查询效率低了，所以当链表的结点数量增多，就好把链表变为红黑树。

3、什么时候链表变为树？

链表的长度达到8时，“考虑”树化。还要看table.length必须达到了64。

如果链表的长度达到8个，但是table.length没有达到64，不会树化，会扩容。

注意：扩容时，因为table.length变了，那么所有HashMap中的键值对Entry对象都要重新计算[index]，

index = hash & table.length-1.

int MIN_TREEIFY_CAPACITY = 64; 最小树化容量

int UNTREEIFY_THRESHOLD = 6; 反树化阈值，就是把树变为链表的阈值

4、为什么要把树又变为链表呢？

因为树比较复杂，而且是红黑树，一旦删除或添加元素，涉及到，变黑变红，左旋右旋，效率低了。

5、什么时候反树化？

当我们删除了树的结点之后，结点数量<=6时，（不是立即转化为链表），再次添加或扩容时，可能转为链表。

JDK1.7的时候(key,value)的类型是Entry类型，

HashMap.Entry内部类实现Map.Entry接口。

JDK1.8的时候 (key,value)的类型是Node或TreeNode类型，

它俩是HashMap.Node或HashMap.TreeNode，也都是实现了 Map.Entry接口。

6、不管是7还是8，Map.Entry接口的实现类结点类型中，都有一个数据项hash，为什么有这个？

hash是key的hashCode值加工过的结果。

添加时用hash，查询时要用hash。

如果在查询/添加过程中，HashMap中的(key,value)很多了，那么意味着我要查询的(key,value)的key与map中已有的(key,value)的key要做hash比较，如果不存起来，每次现算，效率低。存起来，就意味着，如果(key,value)已经存入map了，然后如果key修改了，hashCode值变了，

加工后的hash值不同，会导致找不到，所以key是不能修改的。

JDK1.7时结点的key是final，但是hash不是final的，JDK1.8，结点的key和hash都是final，强调不可变。

六、跟踪1.8HashMap的源码

1、new HashMap<>()

this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted

2、put(key,value)

1）hash(key)：加工key的hashCode

如果key为null，hash还是0

如果key不为null，(h = key.hashCode()) ^ (h >>> 16)

hashCode值是int类型，一共32位。

(h >>> 16)，hashCode值的高16位移到到低16位，低16位没了，现在的高16全是0

(h = key.hashCode()) ^ (h >>> 16) ：高16位异或完不变，低16位与原来高16位做异或，这样的话，目的也是扰乱hashCode值，让hashCode的高16位参与运算。

如果不经过hash(key)，直接拿hashCode & table.length-1做运算，高位作用消失了，table.length一般不会太大。永远是hashCode的低几位在做运算，那么冲突的概率增加了，所以用高16先与低16位做运算，然后再与table.length-1做&运算。

2）当table是null时，resize()方法，初始化了容量和阈值

table=new Node[16];

threshold = 12;

创建了一个新的Node数组

3）计算index = (table.length -1) &hash

判断if(table[index]==null)是否成立，如果成立，直接创建一个结点放到table[index]

4）if(table[index]==null）不成立

先分为三个分支判断：

第一个分支：

判断的是table[index]下的头结点，看头结点的key的hash值是否与新的（key,value)的key的hash一样，并且看key的地址或equals是否相同，即判断头结点的key是否与要新添加的（key,value)的key是否重复。

如果重复，用e记录该结点。

第二个分支：

如果第一个分支没有满足，说明table[index]下的头结点的kye不与新的(key,value)的key重复，判断table[index]的头结点是否是树结点，如果是树结点，尝试把(key,value)添加到树中。如果在整个树中找到了重复结点，会返回重复结点。如果没有重复结点，就会把新(key,value)创建为一个新的TreeNode，添加到红黑树中，添加过程中，涉及到红黑树的结点颜色变化，还有就是左旋右旋保证红黑树遵循它的5个条件。（1、节点是红色或黑色2、根结点是黑的3、每个叶子节点都是黑色的空节点4、每个红节点的两个子节点都是黑色的，不能出现相邻的两个黑节点5、从任意节点到其每个叶子的所有路径都包含相同的黑色节点）

第三个分支：

说明table[index]下面是链表

如果找到了在链表中找到重复元素，会用e记录重复元素。如果没有找到重复元素，会把新的(key,value)创建一个Node结点，放到table[index]最后一个结点的next中，

统计链表的结点个数，如果达到7个（加上新的就是8个），考虑树化。那么此时e为null。

5）if(e!=null)

如果e==null，说明没有重复元素

如果e!=null，说明要么table[index]的头结点是重复元素，要么是树中有一个重复元素，要么是链表中有一个重复元素。找到重复元素的话，就用新的value替换旧的value。结束。

6）if(e!=null)不成立

说明新增了元素

if(++size > threshold) 考虑扩容

JDK1.7新结点是作为链表的头，JDK1.8新结点是作为链表的尾。（七上八下）