HashMap是一个基于数组和链表（红黑树）的数据结构，通过位运算实现高效定位。初始容量为16，当元素超过阈值（默认12）时触发扩容，扩容为原来的两倍。JDK1.8起，当链表长度大于8且数组长度大于64时，链表转为红黑树，以保持高效查找。HashMap在多线程环境下可能存在安全问题，可能导致循环链表。
HashMap源码
HashMap是一个用于存储Key-Value键值对的集合，每一个键值对也叫做Entry。这些个键值对（Entry）分散存储在一个数组当中，这个数组就是HashMap的主干。
我们都知道数组中添加数据，要根据数组下标进行添加，那我们怎么获取下标呢？
通过Entry中的key获取要添加的数组下标index
1.如果直接使用key进行hash算法，得出的结果很难作为下标
System.out.println("1111111111111111".hashCode()); //-1225568000
怎么解决？
可以将index = HashCode（Key） % Length。但是取余的效率很低在HashMap中没有使用。
在HashMap中使用位运算更高效获取index index = HashCode（Key） & （Length - 1）
i = (n - 1) & hash //使用与运算更高效，化为二进制进行与运算只有对应位置全为1结果才是1
但是怎么才能确保与运算出来的结果均匀分布数组下标
在HashMap数组的长度通常固定为16或2的幂 为什么？
1.例如：数组长度(length)为 ：16
“1”的hash值是49对应的二进制为 0011 0001
数组长度(length)为 ：16
(length-1)=15 对应的二进制为0000 1111
”1"的hash值 0011 0001
15 0000 1111
& _________ 求出index=1 ，因为15的高四位全是0 所以与运算求出的index0~15
0000 0001 之间。正好对应数组下标。
2.假如：数组长度(length)为：10
”1"的hash值 0011 0001
9 0000 0101
& _________ 这时候对应的与运算结果只有 0101,0001 ,0100 不会均匀分布数下
0000 0001 标
但是对于数组长度为16的HashMap不管hash值怎么变都是后四位进行与运算，很大概率出现index相同导致链表过长。这使hash值多出的高位没有任何意义。
所以要想办法让高位参与运算
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
扰动函数
为了解决这个问题，在hash方法中又给hashCode添加了一次运算，俗称“扰动函数”。其实本质是把hasCode的也高位拉进来，一起参与运算。hashCode返回的int类型有32位，正好一分为二，划分为高16位和低16位。每次得到hashCode值之后，强行将高16位同低16位先进行一次运算，这样就能够解决hashCode不松散或者等差数列的问题。
这个时候就又出现了另一个问题，为什么要用异或运算而不是其他位运算呢？
- 如果采用与&运算，那么高位就会被0与掉，运算结果整体就会向0方向偏移；
- 如果采取异或^运算，运算结果整体就会向另一个方向偏移；
而异或运算，则是“不同为1，相同为0”，具有更多的随机性和分布性。
右移16位异或可以同时保留高16位于低16位的特征
"1314".hashCode() 1 0111 0000 1011 1100 0101
"1314".hashCode()>>>16 无符号右移 1 0111
^(按位异或相同为0不同为1) __________________________
1 0111 0000 1011 1101 0010
得到的hash值 1 0111 0000 1011 1101 0010
15 1111
& __________________________
0010
这样的运算得到的index散列行更强不至于出现一个下标中链表过长，从而降低hash碰撞的概率。
产生hash冲突
链表解决
将hash冲突的数据使用链表的形式进行尾插法（1.7使用头插法）
数组扩容
(JDK1.8为例)
如图
先知道三个概念
table：存储HashMap节点信息，是个数组
slot：hash槽，即table[i]
bullet：hash桶，相同hash槽上所有元素的集合
这张图有点像一张二维表。HashMap的数据结构采用是分而治之的思想，按照一定的规则将数据一排排存放，查找的时候先找到数据在哪一排，然后在从这排数据挨个找。提高效率。
那么每一排的数据是怎么存放的。以链表的形式存储的，并且满足一些条件时，链表会转化为红黑树。当然，红黑树也会再变成链表。
HashMap简单来说是底层数据结构是数组+链表+红黑树的组合，
数组记录着每一列的位置，链表和红黑树表示列上元素的排列规则。
在源码中，用table表示数组，代码如下
transient Node<K,V>[] table;
Node是HashMap的内部类，是链表上的节点。里面的元素有hash值，键值对以及指向下一个节点的next指针，代码如下：
static class Node<K,V> implements Map.Entry<K,V>{
final int hash;
final K key;
V value;
Node<K,V> next;
HashMap几个重要的元素
默认初始化值16 在创建HashMap时，如果没有指定具体的值，初始化默认是16，即创建的数组的长度，代码如下
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
最大容量，即HashMap能创建的最大容量，能创建的数据的最大长度，代码如下
static final int MAXIMUM_CAPACITY = 1 << 30
负载因子，HashMap的扩容参数之一，浮点类型。默认0.75，代码如下
static final float DEFAULT_LOAD_FACTOR = 0.75f;
链表转化阈值，在jdk1.8后，当Hash桶的元素个数增加，大于等于8时，会转化为红黑树，代码如下
static final int TREEIFY_THRESHOLD = 8;
红黑树转化阈值。当Hash桶的元素个数减少，小于等于6时，会变回链表，代码如下
static final int UNTREEIFY_THRESHOLD = 6;
最小的树形化阈值。只有当HashMap的数组长度超过这个数值时，链表才允许转化的树。
因此，链表转化为树的条件有两个1：HashMap数组长度超过64，2:链表上的元素大于等于8了
代码如下
static final int MIN_TREEIFY_CAPACITY = 64;
HashMap的扩容过程
1.为什么扩容？
HashMap的设计思想是分而治之。如果没有指定初始化容量值，那么HashMap在初始化时会创建一个容量为16的数组。我们可以理解为创建了一个有16列的队伍。然后每插入一个元素，先算出这个元素在第几列，如果该列没有元素，就排上去。如果该列已经有元素了，就插到最后一个元素的后面。那么下次需要找出该元素，只需先找到该元素所在的列，然后再从该列中寻找。提高效率。但是，毕竟只有16列的队伍，随着插入元素的增多，列上的元素也有越来越多，那么其实到后面会很影响查询效率。所以。这时候就需要扩容，即把数组的个数进行扩充。HashMap每次会将数组扩容为之前的两倍。
2.什么时候进行扩容？
jdk1.8源码中，扩容的方法名是resize()
final Node<K,V>[] resize() {
//....
HashMap在这些时候进行扩容：
- 1）第一次put的时候，即第一次插入元素的时候。
当我们创建一个HashMap对象的时候，其实HashMap并没有初始化数组。我们可以看下HashMap的构造方法：
HashMap在这些时候进行扩容：
1）第一次put的时候，即第一次插入元素的时候。
当我们创建一个HashMap对象的时候，其实HashMap并没有初始化数组。我们可以看下HashMap的构造方法：
//无参构造方法
public HashMap() {
//指定负载因子为默认的负载因子，即0.75f
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//两个参数构造方法
//指定初始容量initialCapacity 指定负载因子loadFactor
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
//一个参数构造方法
//调用两个参数的构造方法，初始容量为自己指定，负载因子用默认的DEFAULT_LOAD_FACTOR,即0.75f
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
可以看出HashMap的构造方法主要是初始化一些成员量。而当需要往hashMap插入第一个元素的时候，就需要进行第一次扩容了，毕竟创建对象只是指定成员量，没有实际的空间装东西嘛。代码如下
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
这里调用了resize()，其实就是扩容了。
在resize()方法里
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
这里创建了大小为newCap的Node数组。如果没有指定初始化大小，那么newCap等于DEFAULT_INITIAL_CAPACITY(16)。如果指定了大小，那么newCap等于tableSizeFor(int cap)计算得来的值
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
- 2)当元素个数大于threshold时
if (++size > threshold)
resize();
threshold是扩容的阈值。第一次的阈值是初始化容量*负载因子，按照默认的情况，就是16乘以0.75，为12。
可以看出是当第十二个元素插入完成后，进行扩容。在扩容的过程中，会将阈值扩充为之前的两倍。按照默认的情况下，会变成24，也就是说当第二十四的元素插入完成后，会再进行扩容
- 3）还有一种情况，也会进行扩容，就是当链表上的元素大于8，但是因为数组个数还没到达64嘛，无法转化为红黑树，这时候，也会进行扩容
这个是在treeifyBin方法中，treeifyBin是将链表转化为红黑树的方法。
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
能进入这个方法，说明链表的长度满足大于8的要求了，但是在方法内部有这一层判断，如果tab即数组的长度小于MIN_TREEIFY_CAPACITY，就是64的时候，那么不转红黑树了，也会进行扩容
3.怎么扩容
扩容简单来说就是做了两件事。1：创建一个新数组，原来的两倍大。2：把旧数组的元素放入到新数组中
看看resize()方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//oldTab :老数组
int oldCap = (oldTab == null) ? 0 : oldTab.length; //oldCap :老数组的长度
int oldThr = threshold; //老扩容阈值
int newCap, newThr = 0; //newCap新数组长度，初始为0。newThr 新扩容阈值，初始为0
//如果老数组长度为0(说明不是第一次扩容)
if (oldCap > 0) {
//如果老数组长度大于扩容最大值，没法扩容，直接返回oldTab老数组
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果把老数组的长度增加两倍还是小于最大值 并且老数组长度大于初始长度值
//这个分支比较经常进啦
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && //这里数组长度扩容为原来的
oldCap >= DEFAULT_INITIAL_CAPACITY) //二倍
newThr = oldThr << 1; // 扩容阈值增加两倍
}
//如果老扩容阈值大于0，把新数组的长度设置为老扩容阈值
//什么时候进这个分支。就是老数组为空，且初始的话的时候指定了默认初始值DEFAULT_INITIAL_CAPACITY
else if (oldThr > 0)
newCap = oldThr;
else { // 这里就是无参构造初始化，第一次扩容时
newCap = DEFAULT_INITIAL_CAPACITY;//长度为默认初始化值16
//阈值为负载因子乘以默认初始化值 为 12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//上面的执行完后，如果新的扩容阈值还是0，那么赋值，其实就是有参构造方法初始化，第一次扩容时会进来
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//再把扩容阈值赋值给全局变量threshold，下次扩容时赋值给老扩容阈值时用
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//经过上面的判断，新数组的长度newCap终于被确定出来，两倍长度，然后创建一个新的数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//再把引用指向全局变量table数组（真正使用的）
table = newTab;
//上面说是第一件事：创建一个新的数组，长度为两倍
//============================我是分割符================================
//下里说第二件事：把旧数组的元素放入新的数组里
//resize最后返回的是newTab，所有接下来的操作其实是对newTab进行操作的
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
//创建Node节点e，这个起到临时存储的作用，
//后面都是先将oldTab[i]指向e,然后将oldTab[i]置为null
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)//e.next为null，说明该下标的位置只有一个节点
//重新计算插入的新数组的下标 e.hash&(newCap - 1)，
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode) //如果已经是树节点了
((TreeNode<K,V>)e).split(this, newTab, j, oldCap); //单独用树节点的方法处理
else { // 最后就是链表结构的情况
//声明了5个变量
Node<K,V> loHead = null, loTail = null; //低位头 低位尾 节点
Node<K,V> hiHead = null, hiTail = null; //高位头 高位尾 节点
//低位：0到oldCap-1 高位：oldCap到newCap-1
Node<K,V> next;
//遍历链表
do {
next = e.next;//next用于临时存储节点
//和原来旧数组的位置是一样的（用lo存储新链表）
if ((e.hash & oldCap) == 0) {
if (loTail == null)//尾节点为空，说明链表为空
loHead = e; //指向头节点
else
loTail.next = e;//否则放在链表最后一个
loTail = e;/然后再把e指向尾节点
}
else { //如果位置和旧数组的不一样（用hi存储新链表）
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//最后将分别将lo链表和hi放在指定的位置
if (loTail != null) {
loTail.next = null;//现将尾节点的next节点置为空
newTab[j] = loHead;//放在和原来下标一样的位置
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;//放在原下标加上oldCap的位置
}
}
}
}
}
return newTab;
转换红黑树
当链表长度大于8，并且数组长度大于64时，链表就会转换成红黑树。当链表长度小于6时红黑树就会转换成链表
拓展问题
1.为什么JDK1.8采用红黑树存储Hash冲突的元素？
红黑树本质上是一棵二叉查找树，但它在二叉查找树的基础上增加了着色和相关的性质使得红黑树相对平衡，从而保证了红黑树的查找、插入、删除的时间复杂度最坏为O(log n)。能够加快检索速率。
2.为什么在长度小于8时使用链表，不一直使用红黑树？
桶中元素的插入只会在hash冲突时发生，而hash冲突发生的概率较小，一直维护一个红黑树比链表耗费资源更多，在桶中元素量较小时没有这个必要。
3.为什么要使用红黑树而不使用AVL树？
红黑树与AVLl树，在检索的时候效率差不多，都是通过平衡来二分查找。但红黑树不像avl树一样追求绝对的平衡，红黑树允许局部很少的不完全平衡，这样对于效率影响不大，但省去了很多没有必要的调平衡操作，avl树调平衡有时候代价较大，所以效率不如红黑树。
4.为什么数组容量必须是2次幂？
索引计算公式为i = (n - 1) & hash，如果n为2次幂，那么n-1的低位就全是1，哈希值进行与操作时可以保证低位的值不变，从而保证分布均匀，效果等同于hash%n，但是位运算比取余运算要高效的多。
5.为什么单链表转为红黑树要求桶内的元素个数大于8？
当hashCode离散性很好的时候，树型bin用到的概率非常小，因为数据均匀分布在每个bin中，几乎不会有bin中链表长度会达到阈值。但是在随机hashCode下，离散性可能会变差，然而JDK又不能阻止用户实现这种不好的hash算法，因此就可能导致不均匀的数据分布。不过理想情况下随机hashCode算法下所有bin中节点的分布频率会遵循泊松分布，而一个bin中链表长度达到8个元素的概率为0.00000006，几乎是不可能事件。
同理，少于6就从红黑树转回单链表是为了节省维护一个树的资源消耗，而选择6作为临界值，是因理想情况下一个bin中元素个数达到6的概率是0.00001316，达到7的概率为0.00000094，二者跨度较大，可以减小树和链表之间频繁转化的可能性。
6.为什么jdk1.8之后将量表头插法改为尾插法
jdk1.7先将数组扩容为原来的2倍，在循环插入原数组的数据
多线程下出现扩容死循环，形成循环链表
1.线程1：next1=e1.next
线程2 ：next2=e2.next
在if后开始堵塞
2.线程1正常扩容
3.线程2开始
还是指向原来的位置
4.e.next=newTable[i]
e2.next指向数组索引
5.newTable[i]=e
6.e=next
7.循环执行
next2=e2.next
e.next=newTable[i] 这里本来就连着
newTable[i]=e
e=next 也就是next不在指向3而是e2指向3
在次循环 出现问题
e.next=newTable[i]
这里出现的循环链表
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
