java集合之HashMap分析
1.什么是哈希表？
可以参考这篇文章说的很详细
这篇文章里面详细描述了
-
什么是哈希表
-
什么是哈希冲突
-
如何减少和处理哈希冲突
-
哈希表的扩容和Refresh
基础知识不多赘述
2.HashMap
2.0 前言
1.HashMap的数据结构
2.HashMap的相关参数（初始容量、加载因子）含义以及原因
3.put和get方法操作具体是如何实现
4.Hash的过程以及优缺点
5.rehash造成的线程安全问题以及如何解决，具体见这篇文章
6.扩容的过程
2.1 数据结构
整体设计
散列函数：hashCode()+除留余数法
冲突解决：链地址法
java1.7 数据结构是 数组+链表
java1.8 数据结构是 数据+链表+红黑树
2.2 重要参数
2.2.1 两个重要参数
1.默认初始容量：16，必须是 2 的整数次方
2.默认加载因子的大小：0.75，为什么是0.75上面哈希表文章详细说明
2.2.2 初始容量和加载因子怎么理解
首先根据哈希表，key通过f(key)方法映射到对应的数据下标。
那么初始容量就是数组默认大小，比如10
加载因子就是默认数组填充个数/数组总大小，比如默认大小是10，填充7个就是极限，填充第八个前就要扩容。
若：加载因子越大，填满的元素越多，好处是空间利用率高了，但冲突的机会加大了，链表长度会越来越长、查找效率降低；
反之，加载因子越小，填满的元素则越少，好处是冲突的机会减小了，但空间浪费多了，表中的数据将过于稀疏（很多空间还没用，就开始扩容了）。
2.3 主要方法
2.3.1 put方法解析
java 1.7版本 put方法解析
//put方法
public V put(K key, V value) {
//1.判空操作
if (key == null)
return putForNullKey(value);
//2.拿到key对应的hash
int hash = hash(key.hashCode());
//3.拿到当前key在数组中对应的位置i
int i = indexFor(hash, table.length);
//4.从i开始遍历，这个其实是遍历链表了
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//4.1.判断该链表上是否有相同的key
//如果有直接覆盖原值，并返回原值
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//5.将key，value添加到i处
addEntry(hash, key, value, i);
return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}
1.7版本的put操作可以总结为以下几步
1.判空
2.拿hash值
3.拿数组下标
4.遍历链表赋值
流程就这些，至于细节问题，
比如判断之后如何操作，怎么算的hash值，怎么算的数组下标，怎么添加新数据到数组怎么扩容先不关心。
大致流程先记住，细节可以慢慢思考，过分关注细节，很难把握整体
java 1.8版本 put方法解析
public V put(K key, V value) {
//1.计算hash值，调用内部putVal方法
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//2.判空扩容操作
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);//3.1 节点不存在，创建新节点并添加到数组
else {//3.2 当前节点存在
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p; //3.2.1 直接命中当前节点
else if (p instanceof TreeNode)
//3.2.2 当前节点是红黑树，处理红黑树
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//3.2.3 当前节点是普通链表，遍历链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {//3.2.3.1 新节点追加到尾部
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);//3.2.3.2 链表长度大于8且数组长度大于64，转成红黑树
break;
}
//3.2.3.3 找到覆盖节点退出遍历
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//3.2.4 有覆盖节点，执行交换操作，返回老节点
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);//这是一个空实现的函数，用作LinkedHashMap重写使用。
return oldValue;
}
}
++modCount;
//4 判断是否扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);//这是一个空实现的函数，用作LinkedHashMap重写使用。
return null;
}
java 1.8版本的put操作可以总结为
1.计算hash值
2.判空，空数组扩容
3.1 节点不存在创建新节点，需要就重新创建，并赋值给到数组
3.2 节点存在
3.2.1 命中节点直接替换
3.2.2 命中红黑树节点，转到红黑树处理
3.2.3 命中链表节点，转链表处理，其中包括追加到尾结点和链表转红黑树操作
3.2.3.1 新节点追加尾部
3.2.3.2 链表长度大于8且数组长度大于64，转红黑树
3.2.3.3 找到覆盖节点，退出遍历
3.2.4 有覆盖节点就执行交换操作，并返回老节点
4 最后再次是否扩容
简洁版：
1.拿hash值
2.判空
3.创建新节点或者命中老节点
4.按需扩容
2.3.2 get方法解析
1.7版本 get方法解析
public V get(Object key) {
if (key == null) // 1. 判空操作
return getForNullKey();
int hash = hash(key.hashCode()); //2. 计算hash值
for (Entry<K,V> e = table[indexFor(hash, table.length)]; //3. 计算数组下标，遍历链表
e != null;
e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) //4. 命中返回值
return e.value;
}
return null; //5. 没有命中，返回null
}
1.7版本的get操作可以总结为
1.判空操作
2.计算hash值
3.计算数组下标，遍历链表
4.命中返回值
5.没有命中，返回null
1.8版本 get方法解析
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value; //1.计算hash值
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) { //2.数组判空，计算数组下标并取值判空
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k)))) //3.命中头节点
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode) //4.命中红黑树节点，转红黑树操作
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do { //5.命中链表节点，遍历链表，命中则返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null; //6.数组为空，或者数组下标对应值为null，则返回null
}
1.8版本 get方法可以总结为以下几步
1.计算hash值
2.数组判空，计算数组下表并取值判空
3.命中头节点，直接返回值
4.命中红黑树节点，转红黑树操作
5.命中链表节点，遍历链表，命中则返回
6.数组为空，或数组下标对应值为空，则返回null
简洁版：
1.拿hash值
2.判空
3.命中节点（头节点，红黑树节点，链表节点）
4.返回对应数据
2.3.3 resize方法解析
1.7版本 resize方法解析
resize主要操作有两步
1.根据老数组的长度确定新数组长度并新建一个新数组，新数组长度是老数组长度的二倍
2.将老数组里的值通过重新hash操作命中到新数组中
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length; //1.备份老数组长度，并执行边界合理判断操作
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];//2.创建新数组
transfer(newTable); //3.新老数组数据转移
table = newTable;
threshold = (int)(newCapacity * loadFactor); //4.更新hash容量值
}
/**
* Transfers all entries from current table to newTable.
*/
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {//3.1 遍历数组
Entry<K,V> e = src[j];
if (e != null) {
src[j] = null;
do {
Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity); //3.2 遍历链表，重新计算hash值，调整链表节点
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
}
}
}
1.7版本 resize方法可以总结为以下几步
1.备份老数组长度，执行合理性判断
2.创建新数组
3.新老数组数据转移
3.1遍历数组
3.2遍历链表，重新计算hash值，调整链表节点
4.更新hash容量值
简洁版：
1.创建新数组
2.新老数组数据转移
1.8版本 resize方法解析
因为1.8版本，如果数组为null,会先执行一个扩容操作，所以1.8版本关于老数组的判断条件会多一些
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {//1.老数组不为空，执行长度边界判断，以此确定新数组长度和hash容量
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//2.老数组为空，先确定扩容操作的初始容量和加载因子
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);
}
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) { //3.老数组不为空，遍历老数组执行rehash操作命中到新数组中
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; //3.1 rehash过程中命中头结点
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap); //3.2 rehash操作命中红黑树节点
else { // preserve order
//3.3 命中链表，遍历链表，不用重算hash值，直接重拍
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) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab; //4.老数组为空，或者转移完毕，直接返回新数组
}
1.8版本 resize方法可以总结为以下几步
1.老数组不为空，执行边界判断，以此确定新数组的长度和hash容量
2.老数组为空，初始化初始容量和加载因子
3.老数组不为空，遍历数组，执行新老数组数据转移操作
3.1 命中头结点
3.2 命中红黑树节点
3.3 命中链表，直接根据老数组容量+偏移值即可命中新数组下标（这里下文详细讨论一下）
4.老数组为空，或者转移完毕，返回新数组
简洁版：
同1.7
2.3.4 hash方法解析
1.7版本的 hash操作
/**
* Applies a supplemental hash function to a given hashCode, which
* defends against poor quality hash functions. This is critical
* because HashMap uses power-of-two length hash tables, that
* otherwise encounter collisions for hashCodes that do not differ
* in lower bits. Note: Null keys always map to hash 0, thus index 0.
*/
static int hash(int h) {
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
1.7版本hash操作的理解
计算 key 的 hash 值。
此算法加入了高位计算，防止低位不变，高位变化时，造成的 hash 冲突
1.8版本的 hash操作
/**
* Computes key.hashCode() and spreads (XORs) higher bits of hash
* to lower. Because the table uses power-of-two masking, sets of
* hashes that vary only in bits above the current mask will
* always collide. (Among known examples are sets of Float keys
* holding consecutive whole numbers in small tables.) So we
* apply a transform that spreads the impact of higher bits
* downward. There is a tradeoff between speed, utility, and
* quality of bit-spreading. Because many common sets of hashes
* are already reasonably distributed (so don't benefit from
* spreading), and because we use trees to handle large sets of
* collisions in bins, we just XOR some shifted bits in the
* cheapest possible way to reduce systematic lossage, as well as
* to incorporate impact of the highest bits that would otherwise
* never be used in index calculations because of table bounds.
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
1.8版本hash操作的理解
| 步骤 | 代码实现 | 分析 |
|---|---|---|
| 计算哈希值 | key.hashCode() | 调用hashCode()方法，拿到初始hash值 |
| 二次处理哈希值 | h ^ (h >>> 16) | 本质是高16位与低16位进行一个异或操作 |
| 确定数组位置 | (n - 1) & h | n代表数组长度，h是计算出来的哈希值 |
具体用例分析：
key.hashCode() : 1111 1111 1111 1111 1111 0000 1110 1010
---------------------------------------------------------------
h : 1111 1111 1111 1111 1111 0000 1110 1010
h>>>16 : 0000 0000 0000 0000 1111 1111 1111 1111 计算hash
hash = h ^ (h >>> 16) : 1111 1111 1111 1111 0000 1111 0001 0101
---------------------------------------------------------------
0000 0000 0000 0000 0000 0000 0000 1111 （n - 1）= 15，n初始容量16
1111 1111 1111 1111 0000 1111 0001 0101 hash值
(n - 1) & hash : 0000 0000 0000 0000 0000 0000 0000 0101 结果是0101 即 下标为5
2.3.5 indexFor方法解析
1.7版本的indexFor方法解析
/**
* Returns index for hash code h.
*/
static int indexFor(int h, int length) {
return h & (length-1);
}
这个操作怎么理解呢，从最上面的文章里面介绍哈希表的时候，就说过，哈希表的映射关系才用的是除留取余法，简单说就是模运算
在length为2的整数次幂时，h % length，实际结果跟h & (lenght - 1)值是一样的
比如h=5，lenght = 8
0000 0000 0000 0000 0000 0000 0000 0101 = 5
0000 0000 0000 0000 0000 0000 0000 0111 = （8 - 1）
0000 0000 0000 0000 0000 0000 0000 0101 = 5 结果就还是5
由于与运算比模运算要快，所以这里才用的是与运算代替模运算，同时也可以解释为什么数组长度每次翻2的整数次幂
为什么与运算比模运算要快？
参考这篇为啥要用位运算代替取模呢，就是与运算转成汇编时要比模运算耗费的cpu周期少很多。但是这个例子举得C语言的。
1.8版本同1.7，不多赘述。
2.4 难点理解
2.4.0 为什么加载因子是0.75
1.HashMap基于哈希表实现，采用的是链地址法处理哈希冲突
2.rehash操作由于需要重复创建数组以及重新计算地址，因此是一个非常耗时的操作
有些文章说0.75和泊松分布有关，有些说跟泊松分布没关系，跟二项分布有关系
觉得跟泊松分布有关系的文章认为，加载因子为0.75时，可以满足参数为0.5的泊松分布，但是又给不出来推导过程证明0.75和0.5的泊松分布有确切的数学关系。
觉得跟泊松分布没有关系的文章认为，参数为0.5的泊松分布仅仅是为了解释为什么要在链表长度大于8时才转成红黑树，
举个例子说明，HashMap默认的table[].length=16，在长度为16的HashMap中放入12（0.75*length）个数据，
某一个bin中存放了8个节点的概率是0.00000006
扩容一次，16*2=32，在长度为32的HashMap中放入24个数据，某一个bin中存放了8个节点的概率是0.00000006
再扩容一次，32*2=64，在长度为64的HashMap中放入48个数据，某一个bin中存放了8个节点的概率是0.00000006
至于为什么是0.75，他们认为大于0.75会导致哈希冲突增加，性能不好，小于0.75会导致浪费空间发生多次resize影响效率。
认为0.75只是一个折中选择,还有说一个bin为空还是非空的概率为0.5，通过牛顿二项式计算得到结果为log(2),也只能说是一种猜测。
2.4.1 为什么链表长度为8，并且数组长度大于64时时开始扩展
从java注释来看，这个跟一个统计学里很重要的原理——泊松分布有关。
泊松分布是统计学和概率学常见的离散概率分布，适用于描述单位时间内随机事件发生的次数的概率分布。
1.Lambda是在一定的时间/空间内，事件发生的平均值
2.e是自然常数2.71828...
3.n是事件在这一段时间/空间内发生的次数
4.P是该事件在这段时间/空间内发生的概率
在理想情况下，使用随机哈希码，在扩容阈值（加载因子）为0.75的情况下，节点出现在频率在Hash桶（表）中遵循参数平均为0.5的泊松分布。
忽略方差，即X = λt，P(λt = k)，其中λt = 0.5的情况，按公式：
计算结果如上述的列表所示，当一个bin（可以理解为HashMap table[]中任意一个元素对应的集合）中的链表长度达到8个元素的时候，概率为0.00000006，几乎是一个不可能事件。
所以我们可以知道，其实常数0.5是作为参数代入泊松分布来计算的，而加载因子0.75是作为一个条件，当HashMap长度为length/size ≥ 0.75时就扩容，
（这里就很难理解了，哪里能看出来0.75是一个条件呢？）
在这个条件下，冲突后的拉链长度和概率结果为：
0: 0.60653066
1: 0.30326533
2: 0.07581633
3: 0.01263606
4: 0.00157952
5: 0.00015795
6: 0.00001316
7: 0.00000094
8: 0.00000006
加载因子是0.75，决定了桶中元素到达 8 个的时候概率很小，进而转为红黑树；而不是到达 8 个的时候概率很小所以加载因子是0.75。
（这个是怎么决定的呢，很多文章说并不是这个0.75决定的，我反正是持怀疑态度）
2.4.2 HashMap 初始大小为何是 16
每当插入一个元素时，我们都需要计算该值在数组中的位置，即p = tab[i = (n - 1) & hash]。
当 n = 16 时，n - 1 = 15，二进制为 1111，这时和 hash 作与运算时，元素的位置完全取决与 hash 的大小
倘若不是 16，如 n = 10，n - 1 = 9，二进制为 1001，这时作与运算，很容易出现重复值，如 1101 & 1001，1011 & 1001，1111 & 1001，结果都是一样的，所以选择 16 以及 每次扩容都乘以二的原因也可想而知了
2.4.3 1.8版本扩容优化分析
情况1：扩容后，若hash值 新增参与运算的位 = 0，那么元素在扩容后的位置 = 原始位置
| 扩容前后 | 数组长度-1 (n-1) |
key1对应的hash值 (hash1) |
key1对应的数组下标值 (hash1 & (n - 1)) |
|---|---|---|---|
| 扩容前 (容量=16) |
0000 0000 0000 0000 0000 0000 0000 1111 | 1111 1111 1111 1111 1111 0000 1111 0000 0101 | 1111 1111 1111 1111 1111 0000 1111 0000 0101 = 5 |
| 扩容后 (容量=32) |
0000 0000 0000 0000 0000 0000 0001 1111 (扩容后会增多一位，高位为1) |
1111 1111 1111 1111 1111 0000 1111 0000 0101 (新增参与运算的位=0) |
1111 1111 1111 1111 1111 0000 1111 0000 0101 = 5 (扩容后的位置=原位置) |
情况2：扩容后，若hash值 新增参与运算的位 = 1，那么元素在扩容后的位置 = 原始位置 + 扩容前的旧容量
| 扩容前后 | 数组长度-1 (n-1) |
key2对应的hash值 (hash2) |
key2对应的数组下标值 (hash2 & (n - 1)) |
|---|---|---|---|
| 扩容前 (容量=16) |
0000 0000 0000 0000 0000 0000 0000 1111 | 1111 1111 1111 1111 1111 0000 1111 0001 0101 | 1111 1111 1111 1111 1111 0000 1111 0000 0101 = 5 |
| 扩容后 (容量=32) |
0000 0000 0000 0000 0000 0000 0001 1111 (扩容后会增多一位，高位为1) |
1111 1111 1111 1111 1111 0000 1111 0001 0101 (新增参与运算的位 = 0) |
1111 1111 1111 1111 1111 0000 1111 0001 0101 = 5 + 16 (扩容后的位置 = 原位置 + 扩容前的旧容量) |
2.4.4 多线程安全问题分析
这篇文章说的很详细，不在赘述。疫苗：JAVA HASHMAP的死循环
3.参考文档
Java源码分析：HashMap 1.8 相对于1.7 到底更新了什么？
