基于jdk1.8进行分析的。本来想先分析TreeSet，后来按照HashMap和HashSet的实现方式来看，还是先看TreeMap的源码。TreeMap的内部是基于红黑树来完成的。
红黑树的5个性质：
- 性质 1：每个节点要么是红色，要么是黑色。
- 性质 2：根节点永远是黑色的。
- 性质 3：所有的叶节点都是空节点（即 null），并且是黑色的。
- 性质 4：每个红色节点的两个子节点都是黑色。（从每个叶子到根的路径上不会有两个连续的红色节点）
- 性质 5：从任一节点到其子树中每个叶子节点的路径都包含相同数量的黑色节点。
继承结构
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable可以看到继承于AbstractMap，实现了NavigableMap接口、Cloneable接口、java.io.Serializable接口。NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。
构造函数
//默认构造方法
//构造一个新的，空的TreeMap对象，应用key的自然顺序对其排序
//keys必须实现了Comparable接口。而且，所有的key必须能够互相比较
public TreeMap() {
comparator = null;//默认比较机制
}
//根据指定的Comparator来进行排序
//所有的key必须能够用指定的Comparator进行互相比较
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
//构造已知的map对象为TreeMap
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;//默认比较机制
putAll(m);
}
//构造已知的SortedMap对象为TreeMap
public TreeMap(SortedMap<K, ? extends V> m) {
comparator = m.comparator();//使用已知对象的构造器
try {
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
}成员属性
//此比较器被用来维持tree map中元素的顺序，如果为null，则用key的自然顺序来进行排序
private final Comparator<? super K> comparator;
//根节点
private transient Entry<K,V> root;
//树中的节点数量
private transient int size = 0;
//用于记录结构的改变次数
private transient int modCount = 0;内部类
Entry<K,V>
静态内部类用来表示节点类型。通过下面源码可以看出，定义的就是红黑树节点的需要的信息。
// Red-black mechanics
private static final boolean RED = false;
private static final boolean BLACK = true;
static final class Entry<K,V> implements Map.Entry<K,V> {
K key; //键
V value; //值
Entry<K,V> left; //左节点
Entry<K,V> right; //右节点
Entry<K,V> parent; //父节点
boolean color = BLACK;//默认是黑色的
//根据key、value和parent来创建一个节点对象，颜色为BLACK.
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
}
public int hashCode() {
int keyHash = (key==null ? 0 : key.hashCode());
int valueHash = (value==null ? 0 : value.hashCode());
return keyHash ^ valueHash;
}
public String toString() {
return key + "=" + value;
}
}其他方法就不再列举了。就是正常的equals，set，get，hashCode方法，不再往下介绍。
成员方法
put(K key, V value)
public V put(K key, V value) {
Entry<K,V> t = root;
//如果根节点为空
if (t == null) {
/类型检查，如果k1或k2如果为null，则会抛出NullPointerException异常
compare(key, key); // type (and possibly null) check
//创建一个新的节点
root = new Entry<>(key, value, null);
//更新维护size的值
size = 1;
//更新修改次数
modCount++;
//结束方法，返回null
return null;
}
//现在根节点有值
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
// 比较器对象
Comparator<? super K> cpr = comparator;
// 如果比较器对象不为空，也就是自定义了比较器
if (cpr != null) {
// 循环比较并确定元素应插入的位置(也就是找到该元素的父节点)
do {
parent = t;
// 使用比较器比较插入键值对的key值与父节点t.key的大小
cmp = cpr.compare(key, t.key);
// 如果小于父节点t的值，由于红黑树是一个自平衡二叉搜索树，
// 因此，继续递归到父节点左节点
if (cmp < 0)
t = t.left;
// 如果大于父节点t的值，由于红黑树是一个自平衡二叉搜索树，
// 因此，继续递归到父节点右节点
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);//相等，则用新值替换旧值即可
} while (t != null);
}
else {//没有自定义比较器，那么就用默认的比较器
//没有定义比较器的时候，key不能为空，否则抛出异常
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
// 取出比较器对象
Comparable<? super K> k = (Comparable<? super K>) key;
// 同样是循环比较并确定元素应插入的位置(也就是找到该元素的父节点)
do {
//过程和上面类似，不在赘述
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
//创建新节点，默认是黑
Entry<K,V> e = new Entry<>(key, value, parent);
//根据比较值来把此节点设置为parent的左节点还是右节点
if (cmp < 0)//如果小于parent节点，则放在左节点
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);//插入元素之后要修正，保持红黑树的5点性质
//更新size
size++;
//更新修改次数
modCount++;
//方法返回
return null;
}实现思路大体如下：
- 1、根据key先在红黑树中找出其即将要插入的位置，并插入到树中
- 2、由于添加节点会破坏红黑树，因此在插入元素之后要进行修正（颜色转换和数旋转），保持红黑树的5点性质。
以下一小部分是关于红黑树调整的部分，如果不想关心，或者对数据结构没有基础的话，可以略过。
在插入操作中，红黑树的性质 1 和性质 3 两个永远不会发生改变，因此无需考虑红黑树的这两个特性。 那么接下来，我们把新插入的节点定义为 N 节点，N 节点的父节点定义为 P 节点，P 节点的兄弟节点定义为 U 节点，P 节点父节点定义为 G 节点。
- 情形 1：新节点 N 是树的根节点，没有父节点
- 在这种情形下，直接将它设置为黑色以满足性质 2：根节点永远是黑色的。
- 情形 2：新节点的父节点 P 是黑色
- 在这种情况下，新插入的节点是红色的，因此依然满足性质 4。而且因为新节点 N 有两个黑色叶子节点；但是由于新节点 N 是红色，通过它的每个子节点的路径依然保持相同的黑色节点数，因此依然满足性质 5。
- 情形 3：如果父节点 P 和父节点的兄弟节点 U 都是红色
- 在这种情况下，程序应该将 P 节点、U 节点都设置为黑色，并将 P 节点的父节点设为红色（用来保持性质 5）。现在新节点 N 有了一个黑色的父节点 P。由于从 P 节点、U 节点到根节点的任何路径都必须通过 G 节点，在这些路径上的黑节点数目没有改变（原来有叶子和 G 节点两个黑色节点，现在有叶子和 P 两个黑色节点）。
经过上面处理后，红色的 G 节点的父节点也有可能是红色的，这就违反了性质 4，因此还需要对 G 节点递归地进行整个过程（把 G 当成是新插入的节点进行处理即可）。
- 在这种情况下，程序应该将 P 节点、U 节点都设置为黑色，并将 P 节点的父节点设为红色（用来保持性质 5）。现在新节点 N 有了一个黑色的父节点 P。由于从 P 节点、U 节点到根节点的任何路径都必须通过 G 节点，在这些路径上的黑节点数目没有改变（原来有叶子和 G 节点两个黑色节点，现在有叶子和 P 两个黑色节点）。
- 情形 4：父节点 P 是红色、而其兄弟节点 U 是黑色或缺少；且新节点 N 是父节点 P 的右子节点，而父节点 P 又是其父节点 G 的左子节点。
- 在这种情形下，我们进行一次左旋转对新节点和其父节点进行，接着按情形 5 处理以前的父节点 P（也就是把 P 当成新插入的节点即可）。这导致某些路径通过它们以前不通过的新节点 N 或父节点 P 的其中之一，但是这两个节点都是红色的，因此不会影响性质 5。
- 情形 5：父节点 P 是红色、而其兄弟节点 U 是黑色或缺少；且新节点 N 是其父节点的左子节点，而父节点 P 又是其父节点 G 的左子节点。
- 在这种情形下，需要对节点 G 的一次右旋转，在旋转产生的树中，以前的父节点 P 现在是新节点 N 和节点 G 的父节点。由于以前的节点 G 是黑色，否则父节点 P 就不可能是红色，我们切换以前的父节点 P 和节点 G 的颜色，使之满足性质 4，性质 5 也仍然保持满足，因为通过这三个节点中任何一个的所有路径以前都通过节点 G，现在它们都通过以前的父节点 P。在各自的情形下，这都是三个节点中唯一的黑色节点。
回头下一下关于数据结构的东西，以后大家需要还请继续关注。
fixAfterInsertion(Entry<K,V> x)
这个方法就是用来处理插入后更新维护树结构的方法，如果想研究的，可以往下继续看源码，注释内容我个人感觉已经很详细了。
/** From CLR */
private void fixAfterInsertion(Entry<K,V> x) {
// 将插入节点的颜色设置为红色
x.color = RED;
// 循环条件是x不为空且不是根节点且父节点的颜色是红色
// （如果父节点不是红色，则没有连续的红色节点，不再调整）
//情形一：如果x是root节点，则不需要调整了，只需要设置为黑色即可
while (x != null && x != root && x.parent.color == RED) {
/*
以下所有情况都是x的父节点的颜色为红色，牢记！！！
*/
//如果x的父节点是x的父节点的父节点的左节点
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
// 获取 x 的父节点的兄弟节点
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
// 情形三：如果 x 的父节点的兄弟节点是红色，
// 即父节点P和父节点的兄弟节点y都是红色
if (colorOf(y) == RED) {
// 将 x 的父节点设为黑色
setColor(parentOf(x), BLACK);
// 将 x 的父节点的兄弟节点设为黑色
setColor(y, BLACK);
// 将 x 的父节点的父节点设为红色
setColor(parentOf(parentOf(x)), RED);
//递归地进行整个过程，把parentOf(parentOf(x))
//当成是新插入的节点进行处理即可
x = parentOf(parentOf(x));
} else {
//情形四：如果 x 的父节点的兄弟节点是黑色或者缺少，且x为父节点的右节点
if (x == rightOf(parentOf(x))) {
//左旋转
x = parentOf(x);
rotateLeft(x);
}
//情形 5：父节点 P 是红色、而其兄弟节点 U 是黑色或缺少；
//且新节点 x 是其父节点的左子节点，而父节点 P 又是其父节点 PP的左子节点。
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
}
} else {//如果x的父节点是x的父节点的父节点的右节点
// 获取 x 的父节点的兄弟节点
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
//情形三：(同上) x的父节点的兄弟节点为红色，即x的父节点P和P的兄弟节点均为红色
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
//情形四：如果 x 的父节点的兄弟节点是黑色或者缺少，且x为父节点的左节点
if (x == leftOf(parentOf(x))) {
x = parentOf(x);
rotateRight(x);//右旋
}
// 把 x 的父节点设为黑色
setColor(parentOf(x), BLACK);
// 把 x 的父节点的父节点设为红色
setColor(parentOf(parentOf(x)), RED);
//左旋
rotateLeft(parentOf(parentOf(x)));
}
}
}
root.color = BLACK;
}
//函数功能：获取节点p的父节点。
private static <K,V> Entry<K,V> parentOf(Entry<K,V> p) {
return (p == null ? null: p.parent);
}
//函数功能：获取节点p的左节点
private static <K,V> Entry<K,V> leftOf(Entry<K,V> p) {
return (p == null) ? null: p.left;
}
//函数功能：获取节点p的右节点
private static <K,V> Entry<K,V> rightOf(Entry<K,V> p) {
return (p == null) ? null: p.right;
}get(Object key)
用来根据key获取对应的value，可以看到具体实现是通过getEntry实现的。
public V get(Object key) {
Entry<K,V> p = getEntry(key);
return (p==null ? null : p.value);
}getEntry(Object key)
根据key查询获取对应的节点的值，如果不存在，返回null。
//根据给定的key在Map找出符合要求的Entry，如果在Map中不包含则返回null.
final Entry<K,V> getEntry(Object key) {
// Offload comparator-based version for sake of performance
// 如果有自定义比较器对象，就按照自定义规则遍历二叉树
if (comparator != null)
return getEntryUsingComparator(key);
// 如果key为空，直接抛出空指针异常
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
Entry<K,V> p = root;
//从root节点开始查找
while (p != null) {
//比较key
int cmp = k.compareTo(p.key);
//定位看是左子树还是右子树
if (cmp < 0)
p = p.left;
else if (cmp > 0)
p = p.right;
else//找到了，就想等，返回p节点
return p;
}
//否则返回null
return null;
}可以看到该方法中还调用了一个方法，getEntryUsingComparator(Object key)，源码如下。
getEntryUsingComparator(Object key)
该方法是在定义了比较器的情况下，调用的。
//实现思路上来讲，跟上面的都差不多。所以不再赘述。
final Entry<K,V> getEntryUsingComparator(Object key) {
@SuppressWarnings("unchecked")
K k = (K) key;
Comparator<? super K> cpr = comparator;
if (cpr != null) {
Entry<K,V> p = root;
while (p != null) {
int cmp = cpr.compare(k, p.key);
if (cmp < 0)
p = p.left;
else if (cmp > 0)
p = p.right;
else
return p;
}
}
return null;
}
remove(Object key)
根据key，如果存在删除节点。
public V remove(Object key) {
//先找出指定key的Entry
Entry<K,V> p = getEntry(key);
if (p == null)//如果不存在，返回null
return null;
//存在删除节点处理
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}从源码中可以看出调用了deleteEntry方法。
deleteEntry(Entry<K,V> p)
删除指定节点
//删除节点p,并调整树
private void deleteEntry(Entry<K,V> p) {
modCount++;
size--;
// If strictly internal, copy successor's element to p and then make p
// point to successor.
if (p.left != null && p.right != null) {
Entry<K,V> s = successor(p);
p.key = s.key;
p.value = s.value;
p = s;
} // p has 2 children
// Start fixup at replacement node, if it exists.
Entry<K,V> replacement = (p.left != null ? p.left : p.right);
if (replacement != null) {
// Link replacement to parent
replacement.parent = p.parent;
if (p.parent == null)
root = replacement;
else if (p == p.parent.left)
p.parent.left = replacement;
else
p.parent.right = replacement;
// Null out links so they are OK to use by fixAfterDeletion.
p.left = p.right = p.parent = null;
// Fix replacement
if (p.color == BLACK)
fixAfterDeletion(replacement);
} else if (p.parent == null) { // return if we are the only node.
root = null;
} else { // No children. Use self as phantom replacement and unlink.
if (p.color == BLACK)
fixAfterDeletion(p);
if (p.parent != null) {
if (p == p.parent.left)
p.parent.left = null;
else if (p == p.parent.right)
p.parent.right = null;
p.parent = null;
}
}
}调整红黑树是通过方法fixAfterDeletion(Entry<K,V> x)实现的。源码如下：
// 删除节点后修复红黑树
private void fixAfterDeletion(Entry<K,V> x)
{
// 直到 x 不是根节点，且 x 的颜色是黑色
while (x != root && colorOf(x) == BLACK)
{
// 如果 x 是其父节点的左子节点
if (x == leftOf(parentOf(x)))
{
// 获取 x 节点的兄弟节点
Entry<K,V> sib = rightOf(parentOf(x));
// 如果 sib 节点是红色
if (colorOf(sib) == RED)
{
// 将 sib 节点设为黑色
setColor(sib, BLACK);
// 将 x 的父节点设为红色
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
// 再次将 sib 设为 x 的父节点的右子节点
sib = rightOf(parentOf(x));
}
// 如果 sib 的两个子节点都是黑色
if (colorOf(leftOf(sib)) == BLACK
&& colorOf(rightOf(sib)) == BLACK)
{
// 将 sib 设为红色
setColor(sib, RED);
// 让 x 等于 x 的父节点
x = parentOf(x);
}
else
{
// 如果 sib 的只有右子节点是黑色
if (colorOf(rightOf(sib)) == BLACK)
{
// 将 sib 的左子节点也设为黑色
setColor(leftOf(sib), BLACK);
// 将 sib 设为红色
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x));
}
// 设置 sib 的颜色与 x 的父节点的颜色相同
setColor(sib, colorOf(parentOf(x)));
// 将 x 的父节点设为黑色
setColor(parentOf(x), BLACK);
// 将 sib 的右子节点设为黑色
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
}
}
// 如果 x 是其父节点的右子节点
else
{
// 获取 x 节点的兄弟节点
Entry<K,V> sib = leftOf(parentOf(x));
// 如果 sib 的颜色是红色
if (colorOf(sib) == RED)
{
// 将 sib 的颜色设为黑色
setColor(sib, BLACK);
// 将 sib 的父节点设为红色
setColor(parentOf(x), RED);
rotateRight(parentOf(x));
sib = leftOf(parentOf(x));
}
// 如果 sib 的两个子节点都是黑色
if (colorOf(rightOf(sib)) == BLACK
&& colorOf(leftOf(sib)) == BLACK)
{
// 将 sib 设为红色
setColor(sib, RED);
// 让 x 等于 x 的父节点
x = parentOf(x);
}
else
{
// 如果 sib 只有左子节点是黑色
if (colorOf(leftOf(sib)) == BLACK)
{
// 将 sib 的右子节点也设为黑色
setColor(rightOf(sib), BLACK);
// 将 sib 设为红色
setColor(sib, RED);
rotateLeft(sib);
sib = leftOf(parentOf(x));
}
// 将 sib 的颜色设为与 x 的父节点颜色相同
setColor(sib, colorOf(parentOf(x)));
// 将 x 的父节点设为黑色
setColor(parentOf(x), BLACK);
// 将 sib 的左子节点设为黑色
setColor(leftOf(sib), BLACK);
rotateRight(parentOf(x));
x = root;
}
}
}
setColor(x, BLACK);
}
以上是针对TreeMap增删改查源码的分析。
606
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
