文章目录
写在前面
自己写红黑树的时候，在插入结点的时候发现有时会导致树不平衡，原因是在插入结点比较的时候出现错误，后来想到hashmap用到了红黑树，就看了一下它是怎么比较的。真的更强！接着读了hashmap整个源码。有理解不到位或者错误的地方，请大家指正！本文主要以注释的方式对hashmap源码进行逐条解读，若对hashmap底层结构组成不了解建议先去学习下。
基本属性
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}
这是一个结点内部类，是一个单向链表。使用静态内部类，是为了方便调用，而不用每次调用里面的属性或者方法都需要new一个对象。
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;
}
这是红黑树结点的组成部分
//默认容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大长度
static final int MAXIMUM_CAPACITY = 1 << 30;
初始容量必须是2^n，这是什么呢？其实与向数组下标为(n - 1) & hash的位置存放元素有着很大的关系
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
上面的代码是hash值的计算以及putval()方法的代码片段，我们可以看到它求hash的过程，将32位的hashCode值向右移动16位，高位补0，这是为什么呢？因为hashcode的计算方法导致哈希值的差异主要在高位，而 (n - 1) & hash是忽略了容量以上的高位的，所以 使用h >>>16就是为了避免类似情况的哈希冲突。
我们再来看下(n - 1) & hash操作，为了让hash值得到位置分布更均匀，可以对他 % 运算，但是%运算性能肯定是没有位与运算，而(n - 1) & hash的操作刚好可以约等于取余操作，我们以length = 16来举个例子
length -1 = 15 ，假设hash值为88，他们的二进制分别为
0000 0000 0000 1111
0000 0000 0101 1000
与操作后
0000 0000 0000 1000
可见2^n-1高位都是0，与操作之后还是0，剩下的数字正好为数组下标[0,length-1]范围内
假设长度为11时，那么10的二进制为
0000 0000 0000 1010
我们可以看到后面的1010有两个0无论hash对应的位置是0还是1结果都会变成0，那么
hash碰撞的可能性是不是大大提高了，故这就是初始容量必须是2^n的原因。
//默认负载因子长度
static final float DEFAULT_LOAD_FACTOR = 0.75f;
负载因子：用于表示哈希表中元素填满的程度。
冲突的机会越大，数组中存放的数据(entry)也就越多，也就越密，查找的成本越高。反之，数组中存放的数据也就越稀，查找的成本越低，从而查找的时间越少。默认的0.75f是一个权衡后的值。
//对象使用tree而不是list时的计数阈值
static final int TREEIFY_THRESHOLD = 8;
//容器可能被treeified的最小表容量。
static final int MIN_TREEIFY_CAPACITY = 64;
通过这两个参数我们可以知道当table数组中的一块区域的list有8个元素时，我们要考虑将链表转换成红黑树，然而在树化的过程中首先要看下table的容量是否大于 MIN_TREEIFY_CAPACITY，若不大于那么会进行扩容操作，因为扩容操作也会解决hash冲突的问题。后面resize()源码会详细讲到。
int threshold;
threshold = capacity * loadFactor，当Size>=threshold的时候，那么就要考虑对数组的扩增了，是衡量数组是否需要扩增的一个标准。
static final int UNTREEIFY_THRESHOLD = 6;
如果红黑树的节点被删，且小于该阈值，则变为链表。
transient int size;
记录table的当前容量
//负载因子
final float loadFactor;
构造方法
//无参构造：默认参数为0.75f
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//手动设置容量
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//将其他map映射到hashmap中
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
//自己设置容量和负载因子，负载因子要大于0
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
普通方法
put
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
putVal
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;
//判断 下标为(n - 1) & hash 的元素是否为空，为空的话直接插入该结点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
下标为(n - 1) & hash 的空间有元素
else {
Node<K,V> e; K k;
//p为头指针，若当前结点的key值是否和要插入结点的 hash值相等，相等的话e = p，进行下面的key值相等处理
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果p是红黑树结点类型，调用红黑树插入结点的方法
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//以上条件不符合，说明是此时entry为链表，开始对链表进行遍历，寻找合适的插入位置（尾插）
else {
for (int binCount = 0; ; ++binCount) {
//找到null位置进行插入
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果结点个数到达阈值，开始将链表转化为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果当前结点的key值与要插入的key值相等，那么break，进行key相等的处理
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//由上面插入结点可知e!=null即插入结点key与entry中的结点key相等
if (e != null) { // existing mapping for key
V oldValue = e.value;
//判断值是否可以更改，默认是可以更改的，将当前结点的value值改成插入结点的value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//把原来的值返回
return oldValue;
}
}
//修改次数自增
++modCount;
//插入结点后判断当前容量是否满足扩容条件
if (++size > threshold)
resize();
//无实际意义，在LinkedHashMap用到
afterNodeInsertion(evict);
return null;
}
上面是putvalue插入的大体思路，下面我们再来看下转换成红黑树后是怎么插入结点的吧！
putTreeVal
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;
/**
* dir为比较的结果 -1代表插入结点的值小于当前结点，1则为大于
* ph为当前结点的hash值
* 首先要寻找一个格式的插入位置，红黑树也是满足二叉搜索树的性质，
* 所以需要对插入结点的key值和当前结点key值的进行比较
*/
//首先对 hash值进行比较
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
//如果hash值相等并且两个结点的 key值都相等的话，那么将结点返回，执行putValue中的key值相等的操作
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
//若哈希值不相等且两个结点的 key值都不相等的情况下对象k没有实现Comparable接口或者只用compareTo比较两个对象k相等
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
//判断是否搜索过
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
//以当前结点的左右结点为根分别进行搜索，看是否有与要插入的 k值相等的结点
//若有直接返回该结点，进行putValue中的 key值相等的操作
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;
}
//没有搜索到与插入结点key相等的结点，进行class名以及hashcode的判断
dir = tieBreakOrder(k, pk);
}
//终于确定了当前位置结点插入结点的大小关系了
TreeNode<K,V> xp = p;
//这就是二叉搜索树的规则了，比较值小于0的去当前结点的左结点查找
//大于0的反之，找到为空的也就是插入位置
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;
}
}
}
这是在红黑树中插入结点的基本操作，调整的源码先不做分析了，这篇文章主要还是分析hashmap这一整体结构的源码。红黑树部分的源码分析之后再写吧！就先简单的说下调整规则吧，感兴趣的可以尝试手写一下，再通过和hashmap中的红黑树实现进行下对比。一共分为4大种情况
插入结点后修复红黑树的规则：
1、红黑树为空树，将根节点染为黑色
2、插入节点key已经存在
3、插入节点的父结点为黑色（无需处理）
4、
4-1：插入结点的父结点为红色，其叔叔结点也是红色
（将父结点和叔叔结点都变为黑色，将爷爷结点变为红色，从爷爷结点开始在进行处理）
4-2：叔叔结点为空和为黑色，叔叔结点在爷爷结点的右子树上
4-2-1：插入结点在父结点的左支上（LL） 将父节点变为黑色，爷爷结点变为红色，右旋爷爷结点
4-2-2：插入结点在父结点的右支上（LR） 将父节点进行左旋，对父节点在进行变化处理
4-3：叔叔结点为空和为黑色，叔叔结点在爷爷结点的右子树上
4-3-1：插入结点在父结点的右支上（RR），将父节点变为黑色，爷爷结点变为红色，左旋爷爷结点
4-3-2：插入结点在父结点的左支上（RL），将腹肌诶单右旋，对父节点再进行变化
下面我们看下putTreeVal方法中一下其他的辅助方法
comparableClassFor
static Class<?> comparableClassFor(Object x) {
//判断是否实现了comparable接口
if (x instanceof Comparable) {
Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
//如果是string类型，直接返回string.class
if ((c = x.getClass()) == String.class) // bypass checks
return c;
//判断是否有直接实现的接口
if ((ts = c.getGenericInterfaces()) != null) {
//遍历所有实现的接口
for (int i = 0; i < ts.length; ++i) {
//该接口实现了泛型，获取接口不带参数部分的类型对象且该类型是comparable
if (((t = ts[i]) instanceof ParameterizedType) &&
((p = (ParameterizedType)t).getRawType() ==
Comparable.class) &&
(as = p.getActualTypeArguments()) != null &&//获取泛型参数数组
as.length == 1 && as[0] == c) //该数组只有一个泛型参数，并且实现类型是该类型的本身
return c;
}
}
}
return null;
}
tieBreakOrder
static int tieBreakOrder(Object a, Object b) {
int d;
if (a == null || b == null ||
(d = a.getClass().getName(). //对象的实类名相等的时候
compareTo(b.getClass().getName())) == 0)
//即比较两个对象的hashcode
d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
-1 : 1);
return d;
}
谈到hashcode我们可以再看下hashmap的Node结点是怎么实现hashcode方法的
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
treeifyBin
这个方法就是将链表转换为红黑树，无非就是对链表进行遍历，将遍历的结点插入红黑树中
/*
此方法为将链表中的Node结点转换为TreeNode
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
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;
do {
//生成一个红黑树结点
TreeNode<K,V> p = replacementTreeNode(e, null);
//tl为当前结点，hd为头结点
if (tl == null)
hd = p;
else {
//插入结点
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
我们在树化的时候会看到表的容量会与MIN_TREEIFY_CAPACITY进行比较，如果小于的话会调用 resize()方法，会进行扩容操作， 在 resize源码解读的时候就会明白了。
treeify
这个方法是将转换好的树结点构建一颗红黑树
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.left = x.right = null;
//判断是否有根
if (root == null) {
x.parent = null;
x.red = false;
root = x;
}
else {
//插入结点，和putTreeVal方法思路一样，先比较找到合适的值再插入
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
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);
}
resize
我们再来看下hashmap中的数组初始化以及扩容的源码
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//确定旧表的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//旧表的扩容阈值
int oldThr = threshold;
//新表的容量以及新表的扩容阈值
int newCap, newThr = 0;
//如果旧表的长度大于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时，且旧表的扩容阈值大于0，新表的容量要等于旧表的扩容阈值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//否则的话新表的容量为默认的16，扩容阈值为默认负载因子0.75*16，再强转成int型
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的扩容阈值等于0，看新表的容量是否大于最大容量，新表容量*负载因子是否小于最大容量
//满足条件扩容阈值为乘积的整型，否则为整型的最大值
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;
//获取旧表的元素e
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//判断e的下一个位置是否有连接的结点，没有直接添加的新表的对应位置
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//e下一位置有连接的结点时，判断是否为红黑树类型的结点，是的话进行split方法，进行转移
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
/**
* 判断到这只有可能是链表了，那么将这一整条链表通过hash&oldCap的结果分为两条链表
* 这样操作达到减少一条链表多个结点的效果，提高查找效率
*/
//两条链表的头结点和尾结点，采用尾插的方式
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);
//第一条链表不为空，将这条链表挂在新表的j位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//第二条链表不为空，挂在旧表的j+旧表容量的位置
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
可能链表分成两个链表这一操作第一次看可能会懵，可以类比想下取余操作，假设链表上面有key为64和128两个结点，原来容量是16，对16取余都要挂到下标为0位置，扩容后总总量变成32，是不是可以一个挂到0号位置，一个挂到16号位置即（0+原来的容量），数组下标都是以0开始的么！而源码中是用当前hash值和旧表容量进行与运算，等于0就插在原来索引位置，不等于0就插在 （原来索引+原表的容量）位置。下面我们来看下结点为红黑树结点类型时，其结点是怎么转移的
split
这个方法唯一就是要对分好的两条树结点的链表进行个数的判断，看下扩容进行调整后结点的个数是否小于6，小于的话由原来的红黑树转换成链表形式。因为结点数量少的链表查找效率快！
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
/**
* 开始思路基本上和链表转换相似，还是根据hash&oldCap分成两个树结点类型的链表
*/
TreeNode<K,V> b = this;
// 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) {
//这里判断第一条链表的个数是否<UNTREEIFY_THRESHOLD,默认值是6,小于的话把链表挂在到相应位置
//大于的话将链表转换为树挂到相应位置
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);
else {
tab[index] = loHead;
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
//判断第二条链表，挂的位置下标为：原来索引值+oldCap
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}
get
这个方法是根据key值来获取该结点
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
getNode
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//判断表不为空，找到 hash&(n-1)对应的数组下标
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//判断第一个结点的key是否和查找的key相等，相等直接返回第一个结点
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//判断下一个结点是否为空
if ((e = first.next) != null) {
//若第一个结点属于树结点，调用getTreeNode方法找到对应树结点进行返回
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//遍历整个链表，找到与key值相等的返回，找不到返回null
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
查找相对简单些，其实就是对链表或者红黑树一个遍历的过程，下面看下红黑树是怎么遍历的。
getTreeNode
//如果父节点为空直接返回根节点，否则开始遍历查找这颗二叉树
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
}
find
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
/**
* 红黑树的查找过程其实也是很简单的，查找的结点hash<当前结点hash值时，遍历当前结点的左子树
* 大于反之
*/
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;
//hash值等于key不等于的时候左树为空遍历左树，右树为遍历左子树
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
//左右树都不为空，看是否实现comparable接口，若实现进行比较
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
//若没有实现comparable接口，先查找下当前结点右子树有没有和等于key的结点，有返回，没有查找当前结点的左子树
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
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
/**
* 删除的开始其实也是一个查找的过程，先找到和要删除key值相同的结点，查找部分就不解读了，可以看下get()方法的源码解读
* 直接从删除结点开始
*/
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;
//不是头结点用删除结点的上面结点的next指向删除结点的下面结点
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
总结
先解读到这里吧，我觉得把增删和扩容这些操作源码看明白了，看hashmap其他方法的源码应该就不怎么困难了。读了源码发现每一个模块都十分的严谨，以后自己写代码前要尽量把可能发生的情况都考虑到。在这篇文章中只简单的解读了红黑树的插入结点和查找结点以及扩容红黑树变化链表操作，调整结点只提供了思路，有时间我会参照hashmap源码写一篇红黑树基本操作的文章。hashmap中的红黑树真的实现的太棒了！文章中若有错误的地方，请大家指正！
扫一扫
2277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
