版权声明：本文为博主原创文章，转载需在开头注明出处 https://blog.csdn.net/zfq_lsh/article/details/84997628
目录
4. JDK8以后, 如果相同HasHcode所在位置的Node链表长度超过指定阈值会自动转换成TreeNode红黑树存储
5. JDK8以后, 如果相同HasHcode所在位置的TreeNode红黑树长度低于指定阈值会自动转换成Node链表存储
1. HashMap容器默认的初始化大小为16
/**
* 默认的初始化大小
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 162. HashMap默认的负载因子为0.75
/**
* 容器扩容的负载因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
3. HashMap的存储容器为数组
/**
* HashMap为数组结构， 每个hash存储在指定的节点上， 如果遇到hash相同的节点
* 会以链表或者红黑树的形式保存
*/
transient Node<K, V>[] table;4. JDK8以后, 如果相同HasHcode所在位置的Node链表长度超过指定阈值会自动转换成TreeNode红黑树存储
/**
* 转换成Tree的阈值， 超过这个阈值为转换成Tree结构
*/
static final int TREEIFY_THRESHOLD = 8;5. JDK8以后, 如果相同HasHcode所在位置的TreeNode红黑树长度低于指定阈值会自动转换成Node链表存储
/**
* 由Tree转换回来的阈值，低于这个阈值将被转换为HashTable
*/
static final int UNTREEIFY_THRESHOLD = 6;6. 版本号，并发情况下用于快速迭代失败
/**
* 版本号，记录当前容器的操作次数，多线程情况下快速失败迭代
*/
transient int modCount;7. 新增元素方法解读
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K, V>[] tab;
Node<K, V> p;
int n, i;
//如果容器为空的话。 初始化数组
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//根据hash分配存储位置， 如果该位置为空的话，放置一个新的节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//根据hash分配存储位置， 如果该位置已存在节点
else {
Node<K, V> e;
K k;
//如果当前节点和将要放入的key相同， 保留最新的节点信息
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果是TreeNode的话，调用TreeNode的方法
else if (p instanceof TreeNode)
e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
//如果跟当前节点不一致的话， 遍历链表上的所有节点
else {
for (int binCount = 0; ; ++binCount) {
//如果没有下一个节点的话， 创建一个新的节点， 跳出循环
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//新增元素之后，判定是否需要转成TreeNode
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果找到key相同的节点，保留当前节点的信息为新加入的节点，跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果有相同hash和key的节点的话，返回被覆盖掉的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//替换节点，节点数不发生变化，不需要检查版本号和扩容，直接return就可以
return oldValue;
}
}
//版本号++
++modCount;
//节点数量++ 如果大于阈值的话，需要进行扩容
if (++size > threshold)
resize();
//插入后的回掉函数，目前未做实现处理
afterNodeInsertion(evict);
//新增节点，不返回任何信息
return null;
}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) {
//如果已达到上限的话，不再进行扩容处理，直接返回
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//扩容为原来大小的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//如果原来的阈值>0, 赋值为新的阈值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//如果原来的阈值为0的话，新的容器走默认阈值
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) {
//遍历原始容器，将数据迁移到新的容器里
for (int j = 0; j < oldCap; ++j) {
Node<K, V> e;
//只迁移有数据的节点
if ((e = oldTab[j]) != null) {
oldTab[j] = null;//将原来的节点位置置空， 便于GC回收
//如果没有链表节点， 根据hash重新分配位置
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//如果是TreeNode， 操作TreeNode
else if (e instanceof TreeNode)
((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
else { // preserve order
//维持原有链表的顺序
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;
}9. hashcode的计算方式
/**
* 右位移16位，正好是32bit的一半，自己的高半区和低半区做异或，就是为了混合原始哈希码的高位和低位，
* 以此来加大低位的随机性。而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来。
* <p>
* 这段代码是为了对key的hashCode进行扰动计算，防止不同hashCode的高位不同但低位相同导致的hash冲突。
* 简单点说，就是为了把高位的特征和低位的特征组合起来，降低哈希冲突的概率，也就是说，尽量做到任何一位的变化都能对最终得到的结果产生影响。
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
10. Node链表结构 - 单链表
/**
* 数组的节点实体，容器中的每个元素都是会保存为一个Node
*/
static class Node<K, V> implements Map.Entry<K, V> {
final int hash; //当前节点的hash值
final K key;
V value;
Node<K, V> next; //下一个节点的地址， 相同hash的节点会保存为一个链表
Node(int hash, K key, V value, Node<K, V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}11. TreeNode红黑树结构
/**
* 红黑树实现的节点， 当链表的长度超过阈值的时候，会将链表格式转换为红黑色
*/
static final class TreeNode<K, V> extends LinkedHashMap.Entry<K, V> {
TreeNode<K, V> parent; // red-black tree links
TreeNode<K, V> left;
TreeNode<K, V> right;
TreeNode<K, V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K, V> next) {
super(hash, key, val, next);
}