HashMap 1.8 最详解之行为篇(put(k k,V v),resize())
上一篇 ：https://www.cnblogs.com/lanqingzhou/p/14340587.html
四个hashmap的构造函数一起来说，代码方面没有什么难理解的吧，lz在上一篇中已经把所有属性都详细说了一遍，再来理解这些方法，事半功倍。
前三个方法就围绕这一件事来说，当我们new hashMap的时候怎么控制初始化容量。
这里都有给加载系数赋值 this.loadFactor = DEFAULT_LOAD_FACTOR (默认的是0.75，为什么是0.75 lz在上一篇属性篇有说)
当给了一个初始化的initialCapcity时，会tableSizeFor来算出thershold数值，这个方法我在上一篇有说。
new HashMap()的时候只给loadFactor赋值，并没有给thershold或 capcity，Node<K，V>table 赋值，因为hashMap是在put数据的时候，初始化容量，和ArrayList一样。（怕new出来 然后不用浪费空间？，必须要在新增数据的时候初始化容量，我以为jdk开发是这么以为的，不知道他是不是我以为他以为的以为的）
在put<K,V>的时候当table == null table.length == 0 会执行resize方法
new HashMap(32) 只有thershold赋了值而capcity没有赋值的，这里的oldCap = 0 但是oldThr是有值 所以会 newCap = oldThr；
如果是new HashMap() ,就oldThr和oldCap都是0 就会给 newCap一个默认值16，newThr默认值 capcity * loadFactor = 12；
初始化不赋值，全放在resize里面做，jdk开发心想(我就很帅，代码全复用了，还避免了空间浪费，真帅。) 具体优势在哪，我也不清楚，知道的可以留个言。
第四个构造函数就是把一个map对象放到hashmap中去
可以看出就是重新初始化容量(因为hashmap的容量必须要是2的幂次方，且不能超过MAXNUM_CAPCITY = 1 << 30,
如果超过就是等于这个最大值，不再扩容，让新增的数据hash碰碰碰撞)，然后遍历把原来的map对象一个一个put到hashmap中去。
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
上一篇说过大家都知道hashmap是数组加链表啊，什么什么的，数据结构就是个概念，怎么实现的呢。
hashmap里面存的是 Node<k,v>[ ] table 这个数组对象，而数组里面就是Node对象嘛，
只不过有可能每个数组中存的Node对象的next属性不为空，不为空就是链表。Node对象我在上一篇有说。
如果存的是treeNode对象，哎 那就是红黑树（leftNext，rightNext）。因为TreeNode 继承LinkedHashMap.Entry，而这个Entry继承HashMap.Node
所以hashMap中的数组就是Node数组而已。
首先get(K k)方法就是在hashmap中根据k值取value值。
再看步骤：肯定要先根据key算出hash，有hash值算出下角标(就找了数组位置了)。
如果这个数组下角标存的是链表 就遍历这个链表key对应的value值(代码里的do while就是遍历链表操作)，
是treeNode就遍历是这个树，取key对应的value值（getTreeNode(K,V) )
我再出一个关于树的博客，这里就不再累述 ：https://www.cnblogs.com/lanqingzhou/p/14346100.html
首先TreeNode继承了LinedHashMap.Entry内部类
再看TreeNode的属性值
boolean red；标记是不是红节点，true就是红节点，像没有子节点的节点就标记为黑，所以red=false ，根节点一定是黑节点，所以red = false；
parent 父节点，left 左节点，right 右节点，
prev 上一个节点 ： 做一个tmp标记。临时存储。其实删掉链的时候 ，一些自旋的时候。
getTreeNode就是调用TreeNode的find(int hash,Object k,Class<?> kc)方法
/**
* 从调用此方法的节点开始查找, 通过hash值和key找到对应的节点
* 此方法是红黑树节点的查找, 红黑树是特殊的自平衡二叉查找树
* 平衡二叉查找树的特点：左节点<根节点<右节点
*/
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
// 1.将p节点赋值为调用此方法的节点，即为红黑树根节点
TreeNode<K,V> p = this;
// 2.从p节点开始向下遍历
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
// 3.如果传入的hash值小于p节点的hash值，则往p节点的左边遍历
if ((ph = p.hash) > h)
p = pl;
else if (ph < h) // 4.如果传入的hash值大于p节点的hash值，则往p节点的右边遍历
p = pr;
// 5.如果传入的hash值和key值等于p节点的hash值和key值,则p节点为目标节点,返回p节点
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
else if (pl == null) // 6.p节点的左节点为空则将向右遍历
p = pr;
else if (pr == null) // 7.p节点的右节点为空则向左遍历
p = pl;
// 8.将p节点与k进行比较
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) && // 8.1 kc不为空代表k实现了Comparable
(dir = compareComparables(kc, k, pk)) != 0)// 8.2 k<pk则dir<0, k>pk则dir>0
// 8.3 k<pk则向左遍历(p赋值为p的左节点), 否则向右遍历
p = (dir < 0) ? pl : pr;
// 9.代码走到此处, 代表key所属类没有实现Comparable, 直接指定向p的右边遍历
else if ((q = pr.find(h, k, kc)) != null)
return q;
// 10.代码走到此处代表“pr.find(h, k, kc)”为空, 因此直接向左遍历
else
p = pl;
} while (p != null);
return null;
}
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
判断是否存在这个key，就是用的getNode方法 返回值了就true 没有返回就false；
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
重点来了，它来了 它来了 大家一起看看put 方法和resize方法。很多人只关注这两个方法，但是最好重头到位都有个了解，最能吃透。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 1.校验table是否为空或者length等于0，如果是则调用resize方法进行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 2.通过hash值计算索引位置，将该索引位置的头节点赋值给p，如果p为空则直接在该索引位置新增一个节点即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// table表该索引位置不为空，则进行查找
Node<K,V> e; K k;
// 3.判断p节点的key和hash值是否跟传入的相等，如果相等, 则p节点即为要查找的目标节点，将p节点赋值给e节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 4.判断p节点是否为TreeNode, 如果是则调用红黑树的putTreeVal方法查找目标节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 5.走到这代表p节点为普通链表节点，则调用普通的链表方法进行查找，使用binCount统计链表的节点数
for (int binCount = 0; ; ++binCount) {
// 6.如果p的next节点为空时，则代表找不到目标节点，则新增一个节点并插入链表尾部
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 7.校验节点数是否超过8个，如果超过则调用treeifyBin方法将链表节点转为红黑树节点，
// 减一是因为循环是从p节点的下一个节点开始的
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
// 8.如果e节点存在hash值和key值都与传入的相同，则e节点即为目标节点，跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e; // 将p指向下一个节点
}
}
// 9.如果e节点不为空，则代表目标节点存在，使用传入的value覆盖该节点的value，并返回oldValue
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); // 用于LinkedHashMap
return oldValue;
}
}
//上一篇讲过 modCounti记录操作数的，可以看下lz上一篇
++modCount;
// 10.如果插入节点后节点数超过阈值，则调用resize方法进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict); // 用于LinkedHashMap
return null;
}
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// 1.老表的容量不为0，即老表不为空
if (oldCap > 0) {
// 1.1 判断老表的容量是否超过最大容量值：如果超过则将阈值设置为Integer.MAX_VALUE，并直接返回老表,
// 此时oldCap * 2比Integer.MAX_VALUE大，因此无法进行重新分布，只是单纯的将阈值扩容到最大
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 1.2 将newCap赋值为oldCap的2倍，如果newCap<最大容量并且oldCap>=16, 则将新阈值设置为原来的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 2.如果老表的容量为0, 老表的阈值大于0, 是因为初始容量被放入阈值，则将新表的容量设置为老表的阈值
else if (oldThr > 0)
newCap = oldThr;
else {
// 3.老表的容量为0, 老表的阈值为0，这种情况是没有传初始容量的new方法创建的空表，将阈值和容量设置为默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 4.如果新表的阈值为空, 则通过新的容量*负载因子获得阈值
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 5.将当前阈值设置为刚计算出来的新的阈值，定义新表，容量为刚计算出来的新容量，将table设置为新定义的表。
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})//这个注解就是unchecked 这个警告
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 6.如果老表不为空，则需遍历所有节点，将节点赋值给新表
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) { // 将索引值为j的老表头节点赋值给e
oldTab[j] = null; // 将老表的节点设置为空, 以便垃圾收集器回收空间
// 7.如果e.next为空, 则代表老表的该位置只有1个节点，计算新表的索引位置, 直接将该节点放在该位置
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 8.如果是红黑树节点，则进行红黑树的重hash分布(跟链表的hash分布基本相同)
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 9.如果是普通的链表节点，则进行普通的重hash分布
Node<K,V> loHead = null, loTail = null; // 存储索引位置为:“原索引位置”的节点
Node<K,V> hiHead = null, hiTail = null; // 存储索引位置为:“原索引位置+oldCap”的节点
Node<K,V> next;
do {
next = e.next;
// 9.1 如果e的hash值与老表的容量进行与运算为0,则扩容后的索引位置跟老表的索引位置一样
if ((e.hash & oldCap) == 0) {
if (loTail == null) // 如果loTail为空, 代表该节点为第一个节点
loHead = e; // 则将loHead赋值为第一个节点
else
loTail.next = e; // 否则将节点添加在loTail后面
loTail = e; // 并将loTail赋值为新增的节点
}
// 9.2 如果e的hash值与老表的容量进行与运算为非0,则扩容后的索引位置为:老表的索引位置＋oldCap
else {
if (hiTail == null) // 如果hiTail为空, 代表该节点为第一个节点
hiHead = e; // 则将hiHead赋值为第一个节点
else
hiTail.next = e; // 否则将节点添加在hiTail后面
hiTail = e; // 并将hiTail赋值为新增的节点
}
} while ((e = next) != null);
// 10.如果loTail不为空（说明老表的数据有分布到新表上“原索引位置”的节点），则将最后一个节点
// 的next设为空，并将新表上索引位置为“原索引位置”的节点设置为对应的头节点
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 11.如果hiTail不为空（说明老表的数据有分布到新表上“原索引+oldCap位置”的节点），则将最后
// 一个节点的next设为空，并将新表上索引位置为“原索引+oldCap”的节点设置为对应的头节点
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
// 12.返回新表
return newTab;
}
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/**
* 将链表节点转为红黑树节点
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 1.如果table为空或者table的长度小于64, 调用resize方法进行扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
// 2.根据hash值计算索引值，将该索引位置的节点赋值给e，从e开始遍历该索引位置的链表
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
// 3.将链表节点转红黑树节点
TreeNode<K,V> p = replacementTreeNode(e, null);
// 4.如果是第一次遍历，将头节点赋值给hd
if (tl == null) // tl为空代表为第一次循环
hd = p;
else {
// 5.如果不是第一次遍历，则处理当前节点的prev属性和上一个节点的next属性
p.prev = tl; // 当前节点的prev属性设为上一个节点
tl.next = p; // 上一个节点的next属性设置为当前节点
}
// 6.将p节点赋值给tl，用于在下一次循环中作为上一个节点进行一些链表的关联操作（p.prev = tl 和 tl.next = p）
tl = p;
} while ((e = e.next) != null);
// 7.将table该索引位置赋值为新转的TreeNode的头节点，如果该节点不为空，则以以头节点(hd)为根节点, 构建红黑树
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
//treeifyBin（）树化方法，putVal时 当遍历链表时发现 当前遍历的count 大于treeify_thershold 时执行 treeifyBin();
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/**
* 构建红黑树
*/
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
// 1.将调用此方法的节点赋值给x，以x作为起点，开始进行遍历
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next; // next赋值为x的下个节点
x.left = x.right = null; // 将x的左右节点设置为空
// 2.如果还没有根节点, 则将x设置为根节点
if (root == null) {
x.parent = null; // 根节点没有父节点
x.red = false; // 根节点必须为黑色
root = x; // 将x设置为根节点
}
else {
K k = x.key; // k赋值为x的key
int h = x.hash; // h赋值为x的hash值
Class<?> kc = null;
// 3.如果当前节点x不是根节点, 则从根节点开始查找属于该节点的位置
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
// 4.如果x节点的hash值小于p节点的hash值，则将dir赋值为-1, 代表向p的左边查找
if ((ph = p.hash) > h)
dir = -1;
// 5.如果x节点的hash值大于p节点的hash值，则将dir赋值为1, 代表向p的右边查找
else if (ph < h)
dir = 1;
// 6.走到这代表x的hash值和p的hash值相等，则比较key值
else if ((kc == null && // 6.1 如果k没有实现Comparable接口 或者 x节点的key和p节点的key相等
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
// 6.2 使用定义的一套规则来比较x节点和p节点的大小，用来决定向左还是向右查找
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p; // xp赋值为x的父节点,中间变量用于下面给x的父节点赋值
// 7.dir<=0则向p左边查找,否则向p右边查找,如果为null,则代表该位置即为x的目标位置
if ((p = (dir <= 0) ? p.left : p.right) == null) {
// 8.x和xp节点的属性设置
x.parent = xp; // x的父节点即为最后一次遍历的p节点
if (dir <= 0) // 如果时dir <= 0, 则代表x节点为父节点的左节点
xp.left = x;
else // 如果时dir > 0, 则代表x节点为父节点的右节点
xp.right = x;
// 进行红黑树的插入平衡(通过左旋、右旋和改变节点颜色来保证当前树符合红黑树的要求)
root = balanceInsertion(root, x);
break;
}
}
}
}
// 10.如果root节点不在table索引位置的头节点, 则将其调整为头节点
moveRootToFront(tab, root);
}
/**
* 将root放到头节点的位置
* 如果当前索引位置的头节点不是root节点, 则将root的上一个节点和下一个节点进行关联,
* 将root放到头节点的位置, 原头节点放在root的next节点上
*/
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
int n;
// 校验root是否为空、table是否为空、table的length是否大于0
if (root != null && tab != null && (n = tab.length) > 0) {
// 计算root节点的索引位置
int index = (n - 1) & root.hash;
TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
// 如果该索引位置的头节点不是root节点，则该索引位置的头节点替换为root节点
if (root != first) {
Node<K,V> rn;
tab[index] = root;// 将该索引位置的头节点赋值为root节点
TreeNode<K,V> rp = root.prev; // root节点的上一个节点
// 两个操作是移除root节点的过程
// 如果root节点的next节点不为空，则将root节点的next节点的prev属性设置为root节点的prev节点
if ((rn = root.next) != null)
((TreeNode<K,V>)rn).prev = rp;
// 如果root节点的prev节点不为空，则将root节点的prev节点的next属性设置为root节点的next节点
if (rp != null)
rp.next = rn;
// 将first节点接到root节点后面
// 如果原头节点不为空, 则将原头节点的prev属性设置为root节点
if (first != null)
first.prev = root;
root.next = first;// 将root节点的next属性设置为原头节点
root.prev = null;// root此时已经被放到该位置的头节点位置，因此将prev属性设为空
}
// 检查树是否正常
assert checkInvariants(root);
}
}
assert 关键字：断言。 在这里checkInvariants(root)返回的是true才会走下去，如果返回false 就中断系统。所以，这个关键字要慎用。
assert关键字需要在运行时候显式开启才能生效，否则你的断言就没有任何意义。
用assert来控制了程序的业务流程，那在测试调试结束后去掉assert关键字就意味着修改了程序的正常的逻辑
使用断言就很危险，一旦失败系统就挂了。
/**
* 红黑树规则校验 验证红黑树的准确性
*/
static <K,V> boolean checkInvariants(TreeNode<K,V> t) { // 一些基本的校验
TreeNode<K,V> tp = t.parent, tl = t.left, tr = t.right,
tb = t.prev, tn = (TreeNode<K,V>)t.next;
if (tb != null && tb.next != t) //如果前驱节点存在，但是前驱节点的后继节点不是当前节点
return false;
if (tn != null && tn.prev != t)// 如果后继节点存在，但是后继节点的前驱节点不是当前节点
return false;
if (tp != null && t != tp.left && t != tp.right)// 父节点存在，但是父节点的左子节点、右子节点均不是当前节点
return false;
if (tl != null && (tl.parent != t || tl.hash > t.hash))// 左子节点存在。但是左子节点的父节点不是当前节点或者左子节点的hash值大于当前节点的hash值
return false;
if (tr != null && (tr.parent != t || tr.hash < t.hash))// 右子节点存在。但是右子节点的父节点不是当前节点或者右子节点的hash值小于当前节点的hash值
return false;
if (t.red && tl != null && tl.red && tr != null && tr.red) // 如果当前节点为红色, 则该节点的左右节点不能同时为红色
return false;
if (tl != null && !checkInvariants(tl)) //递归验证左子树
return false;
if (tr != null && !checkInvariants(tr))//递归验证右子树
return false;
return true;
}
一些数据结构的实现的时候，就说不了太细了，能力有限。像 ‘递归’的意思自己get不到，我是真讲不清。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
removeNode()方法和putVal() 的思想是一样的，就不一一讲了，大家可以看下源码 研究研究。
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
clear方法，就是遍历Node<K,V>table数组 把其中所有的引用置空，在把size = 0；就ok了。
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
判断是否存在该value，这里和是否存在某key的方法区别就是 ，这里不用计算hash值了，直接从头到尾的遍历(先遍历数组，在遍历链表)，很耗时间。
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
这里有很多方法都是override Map类的方法，就不一一说了。其实源码方面 不会很难懂得，基础很重要，像这里的链表，红黑树，一定要先理解两种数据结构
知道他们的理论，一些特性，我们再看这些代码 就知道jdk开发是什么思路来实现这些数据结构，理论很重要，一定要先懂数据结构。
还有许多方法没有写上来，还有一些内部类没有说，比如HashMapSpliterator 内部类，后面我会补上一些方法，在另外开一章写一些内部类。
