get 根据key值获取对应的value值
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;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
主要是getNode(),根据传入的key值得出相应的下标值,获取数组中对应的头节点first,如果头结点的key值与传入的key值相同的话,则直接返回头结点,如果不相同,则判断头结点是否还有下一节点,如果没有,直接返回null,如果有则判断当前节点类型是否是树节点类型
如果查询到的节点为树节点
如果是树节点类型,则通过getTreeNode获取相对应的树节点
最后会到这个方法中:
TreeNode#TreeNode()
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;
}
前几个判断主要是比较当前树节点的hash值与要查询的hash值做比较,如果比当前树节点的hash值大,则说明位于当前树节点的右子树,反之则位于左子树,如果两者的hash值相同,则直接返回：
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)
p = (dir < 0) ? pl : pr;
static Class<?> comparableClassFor(Object x) {
if (x instanceof Comparable) {
Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
if ((c = x.getClass()) == String.class) // bypass checks
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;
}
static int compareComparables(Class<?> kc, Object k, Object x) {
return (x == null || x.getClass() != kc ? 0 :
((Comparable)k).compareTo(x));
}
第二个条件是判断key值的合理性,如果是String类型,则直接返回c,如果是其他类型,则先获取到该类型的实现的接口数量,并判断这些接口中是否有Comparable类型的,并且该Comparable中定义的泛型参数的类型是c,则直接返回c，否则则返回null,
第三个条件比较上一个条件的合理性,如果k的类型为kc,则开始比较,否则返回0,如果k > x则返回1,k < x则返回-1,然后根据返回值判断是在当前节点的左子树还是右子树中,然后继续向子树中进行遍历,直至找到相等的key值,最后返回对应的节点值,进而返回节点中所包含的value值
如果查询到的节点是单链表节点
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
如果查询到的节点是个单链表节点,那么会通过while循环遍历这个链表,直至找到对应的value值
remove 删除元素
删除的前半部分跟查找的是一样,先查找到对应的节点,然后在对节点进行删除
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
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;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
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);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
直接看后半部分,再找到对应的节点之后,先判断此节点是否是树节点,如果是树节点则通过removeTreeNode进行操作
树节点的删除操作有些繁琐也有些抽象,在说这个方法之前,先说一些大致的流程:
因为
HashMap中的红黑树内部还维护着一个双链表,所以在删除的时候,会先将要删除的节点的前后节点进行互联操作
删除树中的节点会进行如下判断,然后进行相应的操作
- 如果要删除的节点无子树节点,则直接删除即可,并设置其父子树节点的左/右子树节点为空
- 如果要删除的节点有左/右一个子树节点,则将此子树节点替换为要删除的节点,重新指定其父子树节点的指针即可,
- 如果要删除的节点同时又左右子树节点,则将其左子树节点
红黑树中,我们可以认为左子树节点 < 当前节点 < 右子树节点 而当前节点的左子树节点的子树节点中,最右侧的子树节点则最为接近当前节点,右子树则相反,右子树中的子树节点中,最左侧的子树节点则最为节点当前节点 ，下面会用到这个理论
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;
// first 为当前桶的头结点,root为树的头结点 rl为根节点的左子树节点
TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;
// succ 为当前节点的下一节点 pred为当前节点的上一个节点(用来关联双链表的上下节点)
TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;
// 如果当前节点无前一节点,则当前节点为头结点,则直接将当前节点的下一节点设置为头结点,否则的话将当上一节点(pred)的下一节点指针指向下一节点(next)
if (pred == null)
tab[index] = first = succ;
else
pred.next = succ;
// 如果下一节点不为空 说明当前节点不是尾节点,则将下一节点(next)的前一节点指针指向前一节点(pred),这样,当前节点在双链表中就脱离出来了
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;
}
// 上面解析并使当前链表节点脱离双链表,下面就是使当前树节点脱离红黑树
// p为当前树节点,pl为当前树节点的左子树节点,pr为右子树节点,replacement为要替代当前树节点的节点(下面简称为当前树节点，左子树节点,右子树节点和替换节点)
TreeNode<K,V> p = this, pl = left, pr = right, replacement;
// 如果左右子树节点都不为空 进入判断
if (pl != null && pr != null) {
TreeNode<K,V> s = pr, sl;
// 通过while循环遍历有右子树节点的最左侧的左子树节点,并赋值给s(下面简称为右子树最小树节点)
while ((sl = s.left) != null) // find successor
s = sl;
// 将当前节点的与s节点的颜色进行互换
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;
// 如果此时的右子树最小子树节点的父子树节点为空,则其为根节点,将其赋值给root,否则的话,将父子树节点的的左/右子树节点的指针指向s
if ((s.parent = pp) == null)
root = s;
else if (p == pp.left)
pp.left = s;
else
pp.right = s;
// 此时的sr是当前节点p的右子树节点，如果不为空则将replacement指向sr,否则指向p
if (sr != null)
replacement = sr;
else
replacement = p;
}
else if (pl != null)
replacement = pl;
else if (pr != null)
replacement = pr;
else
replacement = p;
// 上面的三个else 如果当前节点有子树节点则将relpacement指向此子树节点，否则指向p
// 下面就开始使p脱离树了
//下面的判断 如果p有子树节点(无论是替换前还是替换后)即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;
}
// 如果此时的p为红色,则返回root否则进入balanceDeletion,balanceDeletion是重新调整树结构并返回调整后的树的根节点.这里就不在多说了
TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);
// 如果p无子树节点(无论是替换前还是替换后)，使此时的p的父子树节点的左/右子树节点指向null,此时的p也算是脱离出来了
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;
}
}
// 最后通过moveRootToFront重新定义双链表的头部节点使之与树的根节点相同
if (movable)
moveRootToFront(tab, r);
}
回到removeNode最后返回要删除的节点node,删除过程就结束了
网友评论