共同学习Java源代码-数据结构-HashMap(十八)

来源：互联网发布：什么是编程范式编辑：程序博客网时间：2024/06/10 03:53

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;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
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;
}
dir = tieBreakOrder(k, pk);
}

TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
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;
}
}

}

这个方法是插入树节点的方法

首先定义Class类型临时变量kc 布尔临时变量searched默认为false

然后创建root变量获取根节点就是判断本节点的父节点是否为空如果父节点不为空就调用root方法获取如果父节点为空本节点就作为根节点

然后进入for循环遍历每个节点循环变量是p 初始值是root

创建临时变量dir ph和pk

将p的哈希值赋给ph 判断ph如果大于参数h dir就是-1

如果ph小于参数h dir就是1 就是判断传进来的参数的哈希值和这里遍历的节点的哈希值用来确定传进来的参数添加到节点的哪里

如果传进来的k键和遍历中的节点的键一致或为同一对象那么直接返回该节点

如果两个哈希值相同 kc为空且参数键k的类型不是Comparable 或参数k和本节点的键相比的比值为0 那么判断searched变量是否为false 也就是没进行过搜索将search变量设为true 就对p的左子树和右子树进行搜索搜到了和要插入的节点相同的节点就返回搜到的节点最后跳出判断searched变量后调用tieBreakOrder给dir赋值

然后根据dir的值判断如果dir小于等于0 且p的左节点为空或dir大于0 且p的右节点为空

那么将p的下一个节点设置为树节点通过调用参数map的newTreeNode方法将新传入的键值对放在本节点和下一个节点之间的节点操作方式就是本节点的下一个节点作为新节点的下一个节点新节点根据dir值放在本节点的左子树或右子树中新节点作为本节点的下一个节点新节点的上一个节点和父节点都变成成本节点新节点的下一个节点（曾是本节点的下一个节点）的上一个节点设为新节点

然后将根节点移动到哈希桶数组中并调用balanceInsertion方法调整根节点

最后返回空值

search变量设为true

final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
boolean movable) {
int n;
if (tab == null || (n = tab.length) == 0)
return;
int index = (n - 1) & hash;
TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;
TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;
if (pred == null)
tab[index] = first = succ;
else
pred.next = succ;
if (succ != null)
succ.prev = pred;
if (first == null)
return;
if (root.parent != null)
root = root.root();
if (root == null || root.right == null ||
(rl = root.left) == null || rl.left == null) {
tab[index] = first.untreeify(map); // too small
return;
}
TreeNode<K,V> p = this, pl = left, pr = right, replacement;
if (pl != null && pr != null) {
TreeNode<K,V> s = pr, sl;
while ((sl = s.left) != null) // find successor
s = sl;
boolean c = s.red; s.red = p.red; p.red = c; // swap colors
TreeNode<K,V> sr = s.right;
TreeNode<K,V> pp = p.parent;
if (s == pr) { // p was s's direct parent
p.parent = s;
s.right = p;
}
else {
TreeNode<K,V> sp = s.parent;
if ((p.parent = sp) != null) {
if (s == sp.left)
sp.left = p;
else
sp.right = p;
}
if ((s.right = pr) != null)
pr.parent = s;
}
p.left = null;
if ((p.right = sr) != null)
sr.parent = p;
if ((s.left = pl) != null)
pl.parent = s;
if ((s.parent = pp) == null)
root = s;
else if (p == pp.left)
pp.left = s;
else
pp.right = s;
if (sr != null)
replacement = sr;
else
replacement = p;
}
else if (pl != null)
replacement = pl;
else if (pr != null)
replacement = pr;
else
replacement = p;
if (replacement != p) {
TreeNode<K,V> pp = replacement.parent = p.parent;
if (pp == null)
root = replacement;
else if (p == pp.left)
pp.left = replacement;
else
pp.right = replacement;
p.left = p.right = p.parent = null;
}

TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);

if (replacement == p) { // detach
TreeNode<K,V> pp = p.parent;
p.parent = null;
if (pp != null) {
if (p == pp.left)
pp.left = null;
else if (p == pp.right)
pp.right = null;
}
}
if (movable)
moveRootToFront(tab, r);
}