前言
主要对put操作进行了分析，remove操作太复杂了，没有做。如有错漏，请不吝指正。
红黑树
红黑树的特性
红黑树部分参照的博客是： http://www.cnblogs.com/skywang12345/p/3245399.html
同时也参找了相关的hashMap视频： https://www.bilibili.com/video/BV1n64y1T7Pk
《算法导论》中对于红黑树的定义如下:
1.每个结点或是红的，或是黑的
2.根节点是黑的
3.每个叶结点是黑的
4.如果一个结点是红的，则它的两个儿子都是黑的
5.对每个结点，从该结点到其子孙节点的所有路径上包含相同数目的黑结点
注意：
(01) 特性(3)中的叶子节点，是只为空的节点。
(02) 特性(5)，确保没有一条路径会比其他路径长出俩倍。因而，红黑树不需要完全平衡，只需要保证黑节点平衡，是相对是接近平衡的二叉树。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XKndvHIv-1603789985775)(…/…/…/…/imgs/1603680797904.png)]
新插入的节点，直接给红色，
红黑树的时间复杂度为: O(lgn)
变色、左旋和右旋
为了让树保持红黑树的特性，红黑树在插入、编辑或删除节点后，会进行变色、左旋和右旋的相关操作。
**左旋：**设某个节点为旋转点，旋转中心为该节点的右孩子节点。旋转后，调整这两个节点之间以及这两个节点与其它节点的父子关系。最终原旋转节点变成其原右孩子节点的左孩子节点。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1d87EnZx-1603789985777)(…/…/…/…/imgs/1603693070258.png)]
**右旋：**设某个节点为旋转点，旋转中心为该节点的左孩子节点。旋转后，调整这两个节点之间以及这两个节点与其它节点的父子关系。最终原旋转节点变成其原左孩子节点的右孩子节点。
插入
向红黑树中插入新的结点。具体做法是，将新结点的 color赋为红色，然后以BST(二叉查找树)的插入方法插入到红黑树中去。之所以将新插入的结点的颜色赋为红色，是因为︰如果设为黑色，就会导致根到叶子的路径上有一条路上，多一个额外的黑结点，这个是很难调整的。但是设为红色结点后，可能会导致出现两个连续红色结点的冲突，那么可以通过颜色调换和树旋转来调整，这样简单多了。
接下来，讨论一下插入以后，红黑树的情况。设要插入的结点为N，其父结点为P，其祖父结点为G，其父亲的兄弟结点为U〈即P和U是同一个结点的两个子结点)。
如果父结点是黑色的，则整棵树不必调整就已经满足了红黑树的所有性质。
如果父节点是红色（可知，其父结点G一定是黑色的)，则插入N后，违背了红色结点只能有黑色孩子的性质，需要进行调整。，调整时分以下三种情况:
**1、叔叔是红色，父节点+叔叔节点变黑色，祖父节点变为红色，将祖父节点设为当前节点(红色节点)；即，之后继续对当前节点进行操作 **
处理方式:将父节点和叔叔节点修改为黑色，祖父节点修改为红色。
现在新结点N有了一个黑色的父结点P，因为通过父结点P或叔父结点U的任何路径都必定通过祖父结点G，在这些路径上的黑结点数目没有改变。
但是，红色的祖父结点G的父结点也有可能是红色的，这就违反了性质3。为了解决这个问题，我们从祖父结点G开始递归向上调整颜色。
2、叔叔是黑色（空节点默认为黑色），要插入的节点为左孩子节点。旋转+变色
处理方式:对祖父结点进行一次右旋转，在旋转后产生的树中，以前的父结点P现在是新结点N和以前的祖父节点G的父结点，然后父结点变黑和祖父结点变红，结果仍满足红黑树性质。
3、叔叔是黑色，要插入的节点为右孩子节点。旋转+变色
处理方式：对父节点进行左旋，变成情况二
TreeNode
属性
/**
* 属性：父、左孩子、右孩子节点，颜色，prev
* 继承的父属性有 hash、key、value、next等
*/
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 删除时需要断开next链接
boolean red;
}
构造方法
/* 其构造器最终调用的是HashMap里的Node内部类的构造器
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
*/
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
root()：获取根节点
/**
* Returns root of tree containing this node.
* 不断遍历节点的父节点，找到父节点为空的树节点该节点为根节点
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {java
if ((p = r.parent) == null)
return r;
r = p;java
}
}
treeify()：形成与此节点链接的节点树
/**
* Forms tree of the nodes linked from this node.
* @return root of tree
*/
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;//定义一个空的根节点
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;//x为该树节点，next为该树节点的下一个节点
x.left = x.right = null;//初始化该树节点的左右子节点为空
if (root == null) {//如果根节点为空，
x.parent = null;//该树节点的父节点置空
x.red = false;//颜色为黑
root = x;//该树节点作为根节点
}
/**
* 如果根节点不为空
*/
else {
K k = x.key;//定义k为该节点的key
int h = x.hash;//定义h为该节点的hash
Class<?> kc = null;//定义键的类对象
/**
* 从根节点开始往下与该节点比较
* 比较顺序
* 先比较两个节点的key的hashcode
* 如果key的hashcode相等，看该key的类是否实现了泛型为该类的comparable接口，如果是则通过compareto()比较两个key
* 如果key还相等，比较两个key对应的类名是否相等getClass().getName()
* 类名还相等则调用System.identityHashCode(a)方法进行比较
*/
for (TreeNode<K,V> p = root;;) {//定义p，把根节点赋值给p
int dir, ph;
K pk = p.key;//定义pk，把根节点的键赋值给pk
if ((ph = p.hash) > h)//比较根节点与该节点的hash值，
dir = -1;//该节点小于根节点的hash值，dir为-1，大于为1，等于
else if (ph < h)
dir = 1;
else if ((kc == null &&
//如果该节点的键对应的类实现了comparable接口，则返回该类，否则返回null
(kc = comparableClassFor(k)) == null) ||
//如果根节点的键的类与该节点的键的类相同，则等于0
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;//xp表示x的父节点（未确定），x表示this节点
//p表示该节点下一个要比较的节点
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;//xp确定为x的父节点
if (dir <= 0)
xp.left = x;//x为xp的左子节点
else
xp.right = x;//x为xp的右子节点
root = balanceInsertion(root, x);//重新平衡红黑树树
break;
}
}
}
}
moveRootToFront(tab, root);
}
HashMap红黑树插入简述
设定：x为新插入的节点，xp:x的父节点，xpp:x的祖父节点，xppl:x的祖父节点的左孩子节点，xppr:x的祖父节点的右孩子节点
1、在对应位置下插入节点，节点颜色默认设为红色。
2、进行递归（直到父节点或祖父节点为null时，完成最后一次递归），调整红黑树
如果x的父节点为空，说明只是第一个插入的节点，该节点颜色变黑直接作为根节点返回
否则 如果x的父节点的颜色是黑色或x的祖父节点为null则不做任何处理直接返回
如果 父节点为左孩子节点
如果祖父节点的右子节点为红色，父节点和叔叔节点变黑，祖父节点变红，然后让祖父节点xpp作为当前节点x，用于递归
如果祖父节点的右子节点为空或者黑色，旋转加变色
如果x为右孩子节点，父节点需要先左旋，左旋后x和xp的父子关系调换（原来的x变成父节点，原来的xp变成原来x的左孩子节点）。然后先变色（新的xp变成黑色，xpp变红），xpp再进行右旋
如果x为左孩子节点，只需要先变色（新的xp变成黑色，xpp变红），xpp再进行右旋。
如果 父节点为右孩子节点
如果祖父节点的左子节点为红色，父节点和叔叔节点变黑，祖父节点变红，然后让祖父节点xpp作为当前节点x，用于递归
如果祖父节点的左子节点为空或者黑色，旋转加变色
如果x为左孩子节点，父节点需要先右旋，右旋后x和xp的父子关系调换（原来的x变成父节点，原来的xp变成原来x的右孩子节点）。然后先变色（新的xp变成黑色，xpp变红），xpp再进行左旋
如果x为右孩子节点，只需要先变色（新的xp变成黑色，xpp变红），xpp再进行左旋。
balanceInsertion():红黑树插入
/**
* 返回的是root根节点
* root:红黑树的根节点
* x:插入的节点
*左旋要旋转的是父节点（xp）或者是祖父节点（xpp）
*要左旋的是xp还是xpp，取决于哪个节点更靠左
*/
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
x.red = true;//插入的节点默认为红色
/**x为新插入的节点
* xp:x的父节点，
* xpp:x的祖父节点，
* xppl:x的祖父节点的左子节点
* xppr:x的祖父节点的右子节点
*/
//for就是要进行递归，从x节点开始，重新设置x，xp，xpp,xppl,xppr对应的节点，然后找到x，xp，xpp,xppl,xppr中最老的节点作为新的x节点循环，直到找到root节点时返回
for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
//如果x的父节点为空，说明只是第一个插入的节点，该节点颜色变黑直接作为根节点返回
if ((xp = x.parent) == null) {
x.red = false;
return x;
}
//如果x的父节点的颜色是黑色或x的祖父节点为null则不做任何处理直接返回
else if (!xp.red || (xpp = xp.parent) == null)
return root;
if (xp == (xppl = xpp.left)) {//如果父节点为左孩子节点
//如果祖父节点的右子节点为红色，父节点和叔叔节点变黑，祖父节点变红
if ((xppr = xpp.right) != null && xppr.red) {
xppr.red = false;
xp.red = false;
xpp.red = true;
x = xpp;//用于递归
}
//如果祖父节点的右子节点为空或者黑色，旋转加变色
else {
//如果x为右节点，需要先左旋（如果父子关系是父节点和右孩子节点的关系，则需要左旋）
if (x == xp.right) {
//左旋后x和xp的父子关系调换了，
//需要使用x=xp，xp=x.parent变回来，使x，xp，xpp的表示的含义不变
root = rotateLeft(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//再右旋（左节点只需要右旋）
if (xp != null) {
//先变色，再右旋，左旋后的xp节点变黑，xpp节点变红
xp.red = false;
if (xpp != null) {
xpp.red = true;
//右旋
root = rotateRight(root, xpp);
}
}
}
}
else {//如果父节点为右孩子节点（操作类似左孩子节点）
//如果祖父节点的右子节点为红色，父节点和叔叔节点变黑，祖父节点变红
if (xppl != null && xppl.red) {
xppl.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
//如果x为左节点，需要先右旋（如果父子关系是父节点和右孩子节点的关系，则需要右旋）
if (x == xp.left) {
root = rotateRight(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//再左旋
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateLeft(root, xpp);
}
}
}
}
}
}
rotateLeft()：左旋
/* ------------------------------------------------------------ */
// Red-black tree methods, all adapted from CLR
/**
*root：根节点
*p：父节点
**/
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
TreeNode<K,V> p) {
//r旋转前的需要插入的节点
//pp旋转前的祖父节点
//rl旋转前需要插入的节点的左孩子节点
TreeNode<K,V> r, pp, rl;
//左旋开始：
//使r表示旋转前的需要插入的节点（因为是左旋，if考虑的是要插入的节点为右节点的情况）
if (p != null && (r = p.right) != null) {
//p.right = r.left：让原父节点的右孩子节点指向要插入的节点的左孩子节点
//rl = p.right：使rl表示为p的右孩子节点
if ((rl = p.right = r.left) != null)
//使rl的父节点为p
rl.parent = p;
//r.parent = p.parent：使r的父节点为p的父节点（即让r的父节点变成r原来的祖父节点）
//如果p没有父节点，旋转后r为根节点，颜色变黑
if ((pp = r.parent = p.parent) == null)
(root = r).red = false;
//如果有父节点，且原祖父节点的左孩子节点为p，则改左孩子节点为r
else if (pp.left == p)
pp.left = r;
//否则pp的右孩子节点改为r
else
pp.right = r;
//最后r的左孩子节点变成p，p的父节点变成r
r.left = p;
p.parent = r;
}
return root;
}
moveRootToFront():移动红黑树根节点到链表前面
/**
* Ensures that the given root is the first node of its bin.
*/
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
int n;
if (root != null && tab != null && (n = tab.length) > 0) {
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放到table里
TreeNode<K,V> rp = root.prev;//找到root的前一个元素
if ((rn = root.next) != null)//找到root的后一个元素
//设置root的后一个元素的前一个元素为root的前一个元素
((TreeNode<K,V>)rn).prev = rp;
if (rp != null)
//设置root的前一个元素的后一个元素为root的后一个元素
rp.next = rn;
if (first != null)
first.prev = root;
//设置root为链表的第一个元素
root.next = first;
root.prev = null;
}
//要使assert起作用，需要在启动的时候添加-ea参数（该参数意思是enable assert）
//再次验证是否是个红黑树
assert checkInvariants(root);
}
}
put
简述添加过程：
插入时会进入putVal()方法。
首先会判断hashMap里存储数据的table是否为空的
为空：为table扩容
不为空：首先根据key的hash值计算出存储存储新数据的table下标，然后判断该table下标对应的位置是否已有节点
没有节点：根据hash, key, value新建一个Node类型的节点，并把该节点存放到该位置下
有节点：首先比较已存在的节点的节点的hash和key是否与新添加的key-value对象的hash和key是否相等
相等：说明在hashMap中找到了存放该key对象的节点，直接更新value即可。在更新前会判断onlyIfAbsent标志和原来的值是否为null，只有onlyIfAbsent标志为fasle或原来的值为null时，才会更新value，返回久值，put操作完成。
不相等：说明第一个节点不是存放该key对象的节点，需要先判断该节点是TreeNode节点（代表是红黑树），还是Node节点（代表是链表）。
TreeNode节点：说明该table下标的位置下是红黑树，遍历红黑树并插入新数据。
Node节点：说明该table下标的位置下是链表，遍历链表。
如果找到hash与key都相等的Node，则修改该Node的value值，也要判断onlyIfAbsent标志和原来的值是否为null更新value，返回久值，put操作完成。
如果找不到hash与key都相等的Node，使用尾插法插入根据hash、key、value新建的Node对象，然后判断原来的链表长度是否大于链表的阈值（初始值为8），大于或等于需要进行树化。
成功添加（修改不算）一组key-value数据后，修改次数会加一（modCount++），hashMap存储数据的数量加一（++size），然后判断hashMap的size是否大于hsahMap的扩容阈值（threshold），大于则进行扩容。
最后返回null，put操作完成。
putVal()
jdk7多个位移操作是为了让hash的散列性更好一点
jdk8加了红黑树，使查询和插入得效率都有保证，就不用这么散列了
/**
* 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类型得数组
/**Node类型得属性
final int hash;
final K key;
V value;
Node<K,V> next;
*/
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果数组是空的则初始化一下数组
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//i = (n - 1) & hash：计算数组下标，如果tab里该下标下没有节点，则直接新建一个节点并赋值
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//如果第一个节点的key与要插入的节点的key相同，把原来存在的节点赋值给e
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
//如果原来的节点是TreeNode节点
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果是链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//bincount大于等于7（即链表长度大于等于8的时候会树化）
//binCount与新插入的节点没有关系，也就是说链表里有8给节点再添加一个时才会树化
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
//更新
V oldValue = e.value;
//判断要不要跟新
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//在jdk1.8是先加加再扩容，再jdk1.7是直接比较阈值还要判断数组里插入的地方是否为空才扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
简述把key-value添加到红黑树过程
1、找到该红黑树的根节点
2、从根节点开始比较hash，
新插入的值的hash比正在遍历的hash小，索引到左边。不为null则继续比较；为null则说明这是需要插入的位置，使用该key-value新建一个节点插入到该位置上，插入完成后调整红黑树。
新插入的值的hash比正在遍历的hash大，索引到右边，不为null则继续比较为null则说明这是需要插入的位置，使用该key-value新建一个节点插入到该位置上，插入完成后调整红黑树。
否则比较key，
key相等，说明在hashmap中已存在该key，返回该key的节点，用新value值替换旧value
key不相等，（如果key对应的类实现了Comparable接口的话）使用compareTo()比较key，compareTo()返回0，从根节点开始查找具有给定哈希值和键的节点(还会用Comparable的compareTo()比较),找到则返回该节点，用新value值替换旧value。找不到则说明红黑树里给有给定哈希值和键的节点，则只需要找到对应位置，插入即可。
putTreeVal()
/**
* Tree version of putVal.
* putVal的树版本。
*/
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
TreeNode<K,V> root = (parent != null) ? root() : this;//找到根节点
//从根节点开始比较hash，从而判断新添加的值该插入到红黑树的那个位置
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
//新插入的值的hash比正在遍历的hash小，索引到左边
if ((ph = p.hash) > h)
dir = -1;
//新插入的值的hash比正在遍历的hash大，索引到右边
else if (ph < h)
dir = 1;
//新插入的值的hash等于正在遍历的hash，比较key，key相等，直接返回正在遍历的树节点
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
//key不相等，如果key实现了Comparable接口，使用该接口的compareTo()方法对该key进行比较，比较结果为0（即相等的），
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {//搜索过的标志
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;//q表示找到相等的节点
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
//使用hash，k，v，xpn新建TreeNode节点
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
//把该节点插入到对应位置
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
//插入完后对红黑树进行调整
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
root()
/**
* Returns root of tree containing this node.
* 返回包含此节点的树的根。
*/
final TreeNode<K,V> root() {
//循环查找父节点，父节点为null，说明是根节点
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
tieBreakOrder()
/**
* Tie-breaking utility for ordering insertions when equal
* hashCodes and non-comparable. We don't require a total
* order, just a consistent insertion rule to maintain
* equivalence across rebalancings. Tie-breaking further than
* necessary simplifies testing a bit.
*/
static int tieBreakOrder(Object a, Object b) {
int d;
if (a == null || b == null ||
(d = a.getClass().getName().
compareTo(b.getClass().getName())) == 0)
/**Object.hashCode（）方法与System.identityHashCode(object)的区别
* System.identityHashCode方法是java根据对象在内存中的地址算出来的一个数值，不同的地址算出来的结果是不一样的
* String类重新写了hashCode()方法，使得String类对象在内存中的地址不一样，String中hashcode也可能一样**/
//这里使用了java根据对象在内存中的地址算出来的数值进行比较
d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
-1 : 1);
return d;
}
treeifyBin（）：树化
/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//如果数组长度小于64，不会树化，而会进行扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
//生成一个treeNode的双向链表
do {
//通过node生成treeNode
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;//hd表示该treeNode链表的第一个元素
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
//调用第一个节点的方法进行树化
hd.treeify(tab);
}
}
treeify()
/**
* 链表转红黑树.
* @return root of tree
*/
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;//定义树的根节点
//此时的this是双向链表的头结点，遍历该双向链表，使它形成红黑树
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
if (root == null) {
//红黑树的根节点为null，把正在遍历的节点设为红黑树的根，
//并修改该节点的相关属性，使其符合红黑树的特性。
x.parent = null;//父节点为null
x.red = false;//根节点为黑
root = x;//遍历到的节点作为根节点
}
else {//根节点不为空，红黑树已有元素了，
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {//遍历双向链表
int dir, ph;
K pk = p.key;
//根据节点的hash值，判断节点位于左还是右，小于在左，大于在右
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
//如果实现了Comparable接口，根据compareTo()方法进行比较，相等则通过key的hash比较
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
//判断dir，dir小于等于0，左孩子节点，否则右孩子节点。
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
//插入新节点，并进行平衡操作
root = balanceInsertion(root, x);
break;
}
}
}
}
moveRootToFront(tab, root);
}
tieBreakOrder()
static int tieBreakOrder(Object a, Object b) {
int d;
if (a == null || b == null ||
(d = a.getClass().getName().
compareTo(b.getClass().getName())) == 0)
//根据key的hash值进行比较
d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
-1 : 1);
return d;
}
comparableClassFor（）
/**
* Returns x's Class if it is of the form "class C implements
* Comparable<C>", else null.
* 如果x的形式为“类C实现Comparable <C>”，则返回x的类，否则返回null。
*/
static Class<?> comparableClassFor(Object x) {
if (x instanceof Comparable) {//实现了Comparable接口
Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
if ((c = x.getClass()) == String.class) // String类型绕过检查
return c;
if ((ts = c.getGenericInterfaces()) != null) {
for (int i = 0; i < ts.length; ++i) {
if (((t = ts[i]) instanceof ParameterizedType) &&
((p = (ParameterizedType)t).getRawType() ==
Comparable.class) &&
(as = p.getActualTypeArguments()) != null &&
as.length == 1 && as[0] == c) // type arg is c
return c;
}
}
}
return null;
}
compareComparables()
/**
* Returns k.compareTo(x) if x matches kc (k's screened comparable
* class), else 0.
*/
@SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
static int compareComparables(Class<?> kc, Object k, Object x) {
return (x == null || x.getClass() != kc ? 0 :
((Comparable)k).compareTo(x));
}
简述扩容过程：
1、进行扩容操作时，首先会判断原来table是否为空
不为空：如果原来table的容量大于等于运行的最大容量（2的30次方），将阈值设置成最大容量，无法进行扩容了，直接返回旧数组。如果原来table的容量小于运行的最大容量，则把新数组容量设置为原来两倍，如果新容量小于最大容量并且旧容量大于等于默认初始容量（2的4次方），则将新阈值设置成旧阈值的2倍。
为空：空表扩容，说明需要对数组的大小进行初始化，初始化会使用用户自定义的容量（该容量在用户创建HashMap时，在构造方法中会自动转为大于等于该容量的最小的2的幂次方数）或默认初始容量。
2、进行完上述操作后会根据新容量新建一个数组，作为HashMap的新数组，然后进行数据的转移操作。
转移操作会遍历数组每个元素，获取各位置下的元素，不为空，则转移其中的数据。转移数据时会进行判断。
正在遍历的位置下元素只有一个：直接根据元素的hash计算元素在新数组的位置，并把该元素放到新位置下
正在遍历的位置下元素不只一个：
元素是TreeNode类型：这是红黑树。对红黑树进行拆分和转移操作是根据遍历双向链表来完成的。HashMap里形成的红黑树同时也是一个双向链表，先定义好一个低位的链表和一个高位的链表，从头节点开始，遍历双向链表的每个元素，遍历并判断每个元素在新数组里是高位还是低位，高位则把元素添加到高位的链表，低位则把元素添加到低位的链表。遍历完后，会判断高低位两个链表的容量是否小于等于非树化阈值（阈值为6）
小于等于：需要对相应的链表进行非树化（过新建Node结点的方式形成新链表），最后把新链表放到新数组的对应位置上。
大于：直接把链表头结点放到新数组的对应位置上。然后判断高低位链表的头结点是否为null（低位链表会判断高位链表的头结点是否为null，高位链表反之），如果高位链表的头结点为null，说明高位链表为null，红黑树里的所有元素都转移到了低位，因此只需要用原来的红黑树结构表示低位链表，不需要对低位链表进行重新树化的工作，否则，需要对低位链表进行重新树化。对应低位链表头结点为null的情况也做类似操作。
元素是Node类型：这是链表，定义一个低位链表，一个高位链表。遍历元素链表，根据正在遍历的节点的hash和旧容量相与判断该节点在新数组中是处于低位还是高位，低位则使用尾插法把该节点放到低位链表，高位则使用尾插法把该节点放到高位链表。最后把不为空的低位链表和高位链表放到新数组里。完成数据转移。
3、扩容完后返回新数组
resize()：扩容
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
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;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 阈值变成原来2倍
}
//空表扩容
else if (oldThr > 0) // 初始阈值用户自定义的情况
newCap = oldThr;//设置表容量为用户自定义的情况下的容量（该容量为2的幂次方数）
else { // 零初始阈值表示使用默认值
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;
if (e.next == null)
//扩容时只有一个元素，根据元素的hash计算元素在新数组的位置，并把该元素放到该位置下
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//如果不只一个元素，且是红黑树扩容时，进行红黑树的拆分
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { //如果不只一个元素，且是链表，扩容时转移链表的元素
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;
}
split():拆分
/**
* Splits nodes in a tree bin into lower and upper tree bins,
* or untreeifies if now too small. Called only from resize;
* see above discussion about split bits and indices.
* 将树箱中的节点拆分为较高和较低的树箱，如果现在太小，则取消树化。 仅从调整大小调用
* @param map the map
* @param tab the table for recording bin heads
* @param index the index of the table being split
* @param bit the bit of hash to split on
*/
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this;//获取树的头结点（hahsMap里的红黑树，也是一个双向链表）
// Relink into lo and hi lists, preserving order
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
//根据双向链表的特性
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
if ((e.hash & bit) == 0) {//形成低位双向链表
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;//低位链表容量++
}
else {//形成高位双向链表
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;//高位链表容量++
}
}
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
//低位链表容量小于等于非树化阈值，则进行非树化，并把新形成的链表的头结点放到新数组下
tab[index] = loHead.untreeify(map);
else {
//低位链表容量大于非树化阈值，并把新形成的链表的头结点放到新数组下
tab[index] = loHead;
if (hiHead != null)
//如果高位链表头结点不为空，说明原来的红黑树被拆分了，
//则重新对该低位链表进行树化，没有拆分就不用重新树化了
loHead.treeify(tab);
}
}
if (hiHead != null) {//与上一个if类似
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}
moveRootToFront()
/**
* Ensures that the given root is the first node of its bin.
* 确保给定的根是其bin的第一个节点。
* 调整完红黑树后，其根节点与该红黑树代表的双向链表的头结点可能不一致，
* 需要让根节点与头节点保持一致
*/
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
int n;
if (root != null && tab != null && (n = tab.length) > 0) {
int index = (n - 1) & root.hash;
//找到头节点
TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
//如果根节点与头节点不一致，把根节点从双向链表里拿出来，放到双向链表的头部，即作为first（头节点）的前一个结点，然后根节点就是头结点了
if (root != first) {
Node<K,V> rn;
tab[index] = root;
TreeNode<K,V> rp = root.prev;
if ((rn = root.next) != null)
((TreeNode<K,V>)rn).prev = rp;
if (rp != null)
rp.next = rn;
if (first != null)
first.prev = root;
root.next = first;
root.prev = null;
}
assert checkInvariants(root);
}
}
find()
/**
* Finds the node starting at root p with the given hash and key.
* The kc argument caches comparableClassFor(key) upon first use
* comparing keys.
* 查找具有给定哈希值和键的从根p开始的节点。
* kc参数在首次使用比较键时会缓存可比较的ClassFor（key）。
*/
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
if ((ph = p.hash) > h)
p = pl;
else if (ph < h)
p = pr;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.find(h, k, kc)) != null)
return q;
else
p = pl;
} while (p != null);
return null;
}
get
getNode（）
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//判断数组是否为空，且有没有元素，有就根据key的hash找到对应的下标
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {//找到第一个元素判断是否为空
//根据hsah判断第一个结点是否为要找的结点，是则返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//否则判断下一个结点是否为空，不为空则判断第一个结点是不是TreeNode结点
if ((e = first.next) != null) {
//如果是TreeNode结点，则根据红黑树的查找方式查找
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {//否则循环链表，判断key和hash，找到结点并返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
getTreeNode（）
/**
* Calls find for root node.
*/
final TreeNode<K,V> getTreeNode(int h, Object k) {
//判断是否为根结点
return ((parent != null) ? root() : this).find(h, k, null);
}
/**
* Finds the node starting at root p with the given hash and key.
* The kc argument caches comparableClassFor(key) upon first use
* comparing keys.
*/
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;//把this结点赋值给p
do {
//p表示要比较的结点
//h表示要找的结点的hash
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
//比较hash，如果h<p.hash说明在要找的结点在左边，使p指向p的左孩子结点
if ((ph = p.hash) > h)
p = pl;
//大于则指向右孩子结点
else if (ph < h)
p = pr;
//等于则比较key的值，key相等则返回
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
//不相等则判断左右孩子节点是否为空
//有空的情况出现就不用进行comparable的判断了
//左孩子节点为空，则p直接指向右孩子结点
else if (pl == null)
p = pr;
//右孩子节点为空，则p直接指向左孩子结点
else if (pr == null)
p = pl;
//判断是否实现了comparable接口，是则根据compareTo()方法给p赋值
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
//递归查找，如果在右孩子节点找到则返回该结点
else if ((q = pr.find(h, k, kc)) != null)
return q;
else
//右孩子节点找不到则在左孩子节点找
p = pl;
} while (p != null);
return null;
}
remove
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
removeNode()
/**
* Implements Map.remove and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to match if matchValue, else ignored
* @param matchValue if true only remove if value is equal
* @param movable if false do not move other nodes while removing
* @return the node, or null if none
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//p为正在遍历的结点
Node<K,V>[] tab; Node<K,V> p; int n, index;
//判断数组里keyhash对应下标下是否有数据，没有直接返回null
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
//首先找到要删除的node
//如果p的key等于需要删除的key
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
//如果是红黑树结构，根据getTreeNode()找到要删除的结点
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
//如果是链表结构，遍历链表找到要删除的结点
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//如果找到了要删除的结点，比较结点的value属性，相等才进行删除
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果是红黑树结构，使用removeTreeNode进行删除
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果要删除的结点是链表结构的第一个结点，直接把下一个结点放到数组的对应位置
else if (node == p)
tab[index] = node.next;
//如果不是第一个结点，使要删除的结点的前一个结点的next指向删除的结点的下一个结点
else
p.next = node.next;
++modCount;//修改次数加1
--size;//haspmap大小减一
afterNodeRemoval(node);//该方法在hashmap中为空方法，在其子类有实现
return node;
}
}
return null;
}
扫一扫
1668
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
