HashMap（哈希表）
底层数据结构
- HashMap 在 JDK 1.7 前是 数组+链表 的形式来存储，在 JDK 1.8 后是 数组+链表+红黑树
上图为数组+链表的数据模型，每一个Node都是一个
- Node节点源码如下，每一个Node节点都是HashMap的一个存储单位，Node是HashMap的一个内部类，实现了Map.Entry接口，本质上就是一个键值对。
- 存储数据的源码如下：
/**
* The table, initialized on first use, and resized as
* necessary. When allocated, length is always a power of two.
* (We also tolerate length zero in some operations to allow
* bootstrapping mechanics that are currently not needed.)
*/
transient Node<K,V>[] table;
/**
* Holds cached entrySet(). Note that AbstractMap fields are used
* for keySet() and values().
*/
transient Set<Map.Entry<K,V>> entrySet;
源码解析
常量分析
- 初始化容量（DEFAULT_INITIAL_CAPACITY）：创建一个 HashMap 时，table[] 的容量，也就是HashMap的容量。
- Map最大容量（MAXIMUM_CAPACITY）：Map在每次扩容时容量会翻倍，当到达2 的 30次幂时，就最后扩容一次（也是翻倍），然后该HashMap就无法扩容了。
- 阈值DEFAULT_LOAD_FACTOR）：扩容的标志，当当前元素个数除以容量 > 改阈值时，就会进行扩容。可以修改，也可以大于1，但是建议不要修改。
- 链表转红黑树的阈值（TREEIFY_THRESHOLD）：当一个节点的链表长度为 8 时，改节点会变成红黑树结构，而不是一个链表。
- 红黑树转链表的阈值（UNTREEIFY_THRESHOLD）：当红黑树的总节点变成 6 时，红黑树会重新变成链表。
HashMap初始化
- 初始化时会有以下参数可以初始化
int threshold; // 所能容纳的key-value对极限
final float loadFactor; // 负载因子
int modCount;
int size; //初始化容量，总会是2的n次方，例如 9，它会初始化一个 16 的hashMap
- 在HashMap中，哈希桶数组table的长度length大小必须为2的n次方(一定是合数，就算你初始值为奇数，构造器也会自己寻找一个比他大的2的最小次方的数，如初始11最终会变为16)，这是一种非常规的设计，常规的设计是把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数，Hashtable初始化桶大小为11，就是桶大小设计为素数的应用（Hashtable扩容后不能保证还是素数）。HashMap采用这种非常规设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。
- 这里存在一个问题，即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响HashMap的性能。于是，在JDK1.8版本中，对数据结构做了进一步的优化，引入了红黑树。而当链表长度太长（默认超过8）时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。
hashmap为什么8个节点变成红黑树 又为什么到了6个节点才恢复为链表？
空间和时间的权衡：因为treenode所占空间大于链表，所以在链表节点较少时，红黑树的查找效率与链表差异不大，只有节点数差别大时再转化为红黑树，至于为什么选取8节点变为红黑树，这是java设计者通过大量hash转化实例后得到一个值，因为每个节点的分布频率会遵循泊松分布，链表长度达到8个元素的概率为百万分之6（0.00000006），至于转化红黑树的阈值8和转化为链表的阈值6不一样，我认为是为了避免频繁来回转化。红黑树：
1、节点是红色或黑色。
2、根是黑色。
3、所有叶子都是黑色（叶子是NIL节点）。
4、每个红色节点必须有两个黑色的子节点。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）
5、从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点（简称黑高）。
put方法解析
1、哈希表为解决冲突一般有两种方法：
- 链地址法：HashMap用的就是这种方法，当存在冲突时将该节点变成链表。（细节后续会讲）
- 开放地址法：重新寻找节点位置。
2、Hash 值计算
- 这里的Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。
- 每个对象都有它的 hashCode，如果返回值相同，那么程序调用方法所计算出来的 hash码必然相同。一般简单的hash计算就是对容量进行取模，这样一来元素的分配会比较均匀。但是，模运算的开销还是比较大的。我们对比下JDK 1.7 和 JDK 1.8 的源码。
方法一：
static final int hash(Object key) { //jdk1.8 & jdk1.7
int h;
// h = key.hashCode() 为第一步 取hashCode值
// h ^ (h >>> 16) 为第二步 高位参与运算，使hash值分布更均匀
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
方法二：
static int indexFor(int h, int length) { //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
return h & (length-1); //第三步 取模运算，效率比取模%高
}
我们可以看到它通过 h & (table.length -1) 来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方（后面扩容会提及），这是HashMap在速度上的优化。当length总是2的n次方时，h& (length-1)运算等价于对length取模(保证求出的下标大小在0到length-1之间)，也就是h%length，但是&比%具有更高的效率。
在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。以下为计算过程。
3、细谈put方法：
- put方法的流程图
添加时，会先判断数组是否为空，如果为空则会初始化数组，接着计算hash值，当该位置为空则直接添加，若不为空则会判断该key是否存在，存在就覆盖，否则添加插入进去，如果该位置为链表，在 JDK 1.7 中会插入到链表头中，而 JDK 1.8 则是插入到链表尾部，若该位置为红黑树则直接插入该键值对。若链表长度大于8则该位置会变成一个红黑二叉树。若数组中的个数除以容量大于规定阈值则该hashMap会扩容。
①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；
②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；
③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；
④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤；
⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。
//JDK 1.8 源码
1 public V put(K key, V value) {
2 // 对key的hashCode()做hash
3 return putVal(hash(key), key, value, false, true);
4 }
5
6 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
7 boolean evict) {
8 Node<K,V>[] tab; Node<K,V> p; int n, i;
9 // 步骤①：tab为空则创建
10 if ((tab = table) == null || (n = tab.length) == 0)
11 n = (tab = resize()).length;
12 // 步骤②：计算index，并对null做处理
13 if ((p = tab[i = (n - 1) & hash]) == null)
14 tab[i] = newNode(hash, key, value, null);
15 else {
16 Node<K,V> e; K k;
17 // 步骤③：节点key存在，直接覆盖value
18 if (p.hash == hash &&
19 ((k = p.key) == key || (key != null && key.equals(k))))
20 e = p;
21 // 步骤④：判断该链为红黑树
22 else if (p instanceof TreeNode)
23 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
24 // 步骤⑤：该链为链表
25 else {
26 for (int binCount = 0; ; ++binCount) {
27 if ((e = p.next) == null) {
28 p.next = newNode(hash, key,value,null);
//链表长度大于8转换为红黑树进行处理
29 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
30 treeifyBin(tab, hash);
31 break;
32 }
// key已经存在直接覆盖value
33 if (e.hash == hash &&
34 ((k = e.key) == key || (key != null && key.equals(k)))) break;
36 p = e;
37 }
38 }
39
40 if (e != null) { // existing mapping for key
41 V oldValue = e.value;
42 if (!onlyIfAbsent || oldValue == null)
43 e.value = value;
44 afterNodeAccess(e);
45 return oldValue;
46 }
47 }
48 ++modCount;
49 // 步骤⑥：超过最大容量 就扩容
50 if (++size > threshold)
51 resize();
52 afterNodeInsertion(evict);
53 return null;
54 }
链表插入图：
JDK 1.7 在头插法后如果扩容会使原先的先后顺序颠倒，而 JDK 1.8 在尾插入后不会修改原先的先后顺序。
扩容机制
扩容就是增加将原先的容量（table[]），然后重新计算每一个键值对的hash值，然后重新插入，当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。我们分析下resize的源码，鉴于JDK1.8融入了红黑树，较复杂，为了便于理解我们仍然使用JDK1.7的代码，好理解一些，本质上区别不大，具体区别后文再说。
//JDK 1.7 的主要源码
1 void resize(int newCapacity) { //传入新的容量
2 Entry[] oldTable = table; //引用扩容前的Entry数组
3 int oldCapacity = oldTable.length;
4 if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了
5 threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
6 return;
7 }
8
9 Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组
10 transfer(newTable); //将数据转移到新的Entry数组里
11 table = newTable; //HashMap的table属性引用新的Entry数组
12 threshold = (int)(newCapacity * loadFactor);//修改阈值
13 }
//transfer源码
1 void transfer(Entry[] newTable) {
2 Entry[] src = table; //src引用了旧的Entry数组
3 int newCapacity = newTable.length;
4 for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
5 Entry<K,V> e = src[j]; //取得旧Entry数组的每个元素
6 if (e != null) {
7 src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
8 do {
9 Entry<K,V> next = e.next;
10 int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
11 e.next = newTable[i]; //标记[1]
12 newTable[i] = e; //将元素放在数组上
13 e = next; //访问下一个Entry链上的元素
14 } while (e != null);
15 }
16 }
17 }
- 可以看到 JDK 1.7 的源码还是比较清晰的，后面我们来看一下 JDK 1.8 的源码
/**
初始化或增加表的大小（扩容）。
如果null，则按照在字段阈值中持有的初始容量目标分配。
否则，因为我们使用的是两种扩展的功能，每个箱子中的元素必须保持在相同的索引上，或者在新表中使用两个偏移量。
*/
final Node<K, V>[] resize() {
Node<K, V>[] oldTab = table;
// 获取扩容前table长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 这个值是2的次方，数组长度
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) { //如果大于Map最大容量，会进行最后一次扩容，扩大后直接返回，若达到最大，就只好让他去碰撞了
threshold = Integer.MAX_VALUE;
return oldTab;
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 最大容量翻倍
} else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算新的resize上限
if (newThr == 0) {
float ft = (float) newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
(int) ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes", "unchecked"})
Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
table = newTab;
if (oldTab != null) {
// 把每个bucket都移动到新的buckets中
for (int j = 0; j < oldCap; ++j) {
Node<K, V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;//jdk1.7中重新算
else if (e instanceof TreeNode) //插入红黑二叉树的情况
((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
else { // preserve order
// JDK8之前是transfer方法，多线程操作可能引起cpu100%
Node<K, V> loHead = null, loTail = null;
Node<K, V> hiHead = null, hiTail = null;
Node<K, V> next;
do { //链表的尾部插入，先查询到尾部，在进行插入
next = e.next;
if ((e.hash & oldCap) == 0) {//JDK 1.8 的hash优化，只需要判断新的一个bit位是否为1，当前是为0的情况，插入到久的位置
if (loTail == null) //找到尾巴
loHead = e;
else
loTail.next = e;
loTail = e;
} else { //为 1 的情况，插入到前半部的位置，加快了计算
if (hiTail == null) //找到尾巴
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) { //当前最新bit位为0的情况，原索引放到bucket里
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) { //当前最新bit位为1的情况，原索引+oldCap放到bucket里
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
-
下面举个例子说明下扩容过程。假设了我们的hash算法就是简单的用key mod 一下表的大小（也就是数组的长度）。其中的哈希桶数组table的size=2， 所以key = 3、7、5，put顺序依次为 5、7、3。在mod 2以后都冲突在table[1]这里了。这里假设负载因子 loadFactor=1，即当键值对的实际大小size 大于 table的实际大小时进行扩容。接下来的三个步骤是哈希桶数组 resize成4，然后所有的Node重新rehash的过程。
-
通过观察可以看到同一位置上新元素总会被放在链表的头部位置；这样先放在一个索引上的元素终会被放到Entry链的尾部，而尾插法不会修改原先的顺序。
扩容时容量会增加一倍，由于容量都是2的n次方，所以在最后的取模时，只需要计算最新一位就可以确定位置了。经过观测可以发现，我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。
元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap（扩容前的数组长度）。这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。
总结
1、jdk1.8中当链表数目大于8时会将链表转换为红黑树
2、新链表插入顺序不同（1.7头部插入，1.8尾部插入）
3、hash算法简化
4、resize逻辑修改(jdk7会出现死循环，jdk8不会)
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
