JDK1.8源码阅读记录
JAVA.Util包
TreeMap类
说明
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable
TreeMap是基于Navigable接口的红黑树，而NavigableMap接口继承着SortedMap接口，因此TreeMap是有序的。它根据键值大小进行排序迭代，默认为升序，对于containkey、get、put、remove操作，时间复杂度为log（n）。
TreeMap不是线程安全的，在多线程环境下要在外部进行同步。
因为TreeMap底层基于红黑树实现，所以在了解TreeMap前，最好先了解红黑树。
红黑树简单介绍
红黑树是自平衡二叉树，树中的任何节点的值大于它的左子节点，小于它的右子节点，能够改善普通二叉树在生成过程中的易失衡问题，自行维护平衡。红黑树平衡的维护，建立在以下五条性质上：
- 节点是红色或黑色。
- 根是黑色。
- 所有叶子都是黑色（叶子是NIL节点）。
- 每个红色节点必须有两个黑色的子节点。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）
- 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点（简称黑高）。
为了达到以上性质，红黑树还附有左旋、右旋、着色这几个关键的操作，在本文不作介绍，具体网上搜索。
TreeMap类方法
在JDK1.8中，TreeMap类有3000行代码，但本文并不打算介绍所有的代码，主要挑选几个我们常用的代码进行分析。这些方法实现的功能分别是查找、遍历、插入、删除，至于其他的方法，小伙伴们如有兴趣自己分析。
由于TreeMap类核心部分是红黑树的实现，绝大部分的方法基本都是对底层红黑树的增删改操作的封装，因此在阅读本文时，最好先了解红黑树的原理。
查找
public V get(Object key) {
Entry<K,V> p = getEntry(key);
return (p==null ? null : p.value);
}
final Entry<K,V> getEntry(Object key) {
// Offload comparator-based version for sake of performance
if (comparator != null)
return getEntryUsingComparator(key);
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
Entry<K,V> p = root;
while (p != null) {
int cmp = k.compareTo(p.key);
if (cmp < 0)
p = p.left;
else if (cmp > 0)
p = p.right;
else
return p;
}
return null;
}
因为TreeMap基于红黑树，所以本类的查找操作流程和二叉树一致：
- 先将目标值和根节点的值进行比较，
- 如果目标值小于根节点的值，则再和根节点的左孩子进行比较。如果目标值大于根节点的值，则继续和根节点的右孩子比较。
- 在查找过程中，如果目标值和二叉树中的某个节点值相等，则返回 true，否则返回 false。
在 TreeMap 中，节点（Entry）存储的是键值对<k,v>。在查找过程中，比较的是键的大小，返回的是值，如果没找到，则返回null。TreeMap 中的查找方法是get，具体实现在getEntry方法中。getEntry方法中的while循环就是查找操作的核心逻辑。
遍历
public Set<K> keySet() {
return navigableKeySet();
}
public NavigableSet<K> navigableKeySet() {
KeySet<K> nks = navigableKeySet;
return (nks != null) ? nks : (navigableKeySet = new KeySet<>(this));
}
static final class KeySet<E> extends AbstractSet<E> implements NavigableSet<E> {
private final NavigableMap<E, ?> m;
KeySet(NavigableMap<E,?> map) { m = map; }
public Iterator<E> iterator() {
if (m instanceof TreeMap)
return ((TreeMap<E,?>)m).keyIterator();
else
return ((TreeMap.NavigableSubMap<E,?>)m).keyIterator();
}
// 省略非关键代码
}
Iterator<K> keyIterator() {
return new KeyIterator(getFirstEntry());
}
final class KeyIterator extends PrivateEntryIterator<K> {
KeyIterator(Entry<K,V> first) {
super(first);
}
public K next() {
return nextEntry().key;
}
}
abstract class PrivateEntryIterator<T> implements Iterator<T> {
Entry<K,V> next;
Entry<K,V> lastReturned;
int expectedModCount;
PrivateEntryIterator(Entry<K,V> first) {
expectedModCount = modCount;
lastReturned = null;
next = first;
}
public final boolean hasNext() {
return next != null;
}
final Entry<K,V> nextEntry() {
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
// 寻找节点 e 的后继节点
next = successor(e);
lastReturned = e;
return e;
}
// 其他方法省略
}
TreeMap的遍历操作，一般都是通过对key集合或entry集合进行遍历，然后再根据需要取出键和值，因此，对于遍历操作，我们需要知道keyset集合和entry的内部代码。keySet 方法返回的是KeySet类的对象。这个类实现了Iterable接口，可以返回一个迭代器。该迭代器的具体实现是KeyIterator，而 KeyIterator 类的核心逻辑是在PrivateEntryIterator中实现的。上面的代码虽多，但核心代码还是 KeySet 类和 PrivateEntryIterator 类的 nextEntry方法。
nextEntry 方法是如何保证键的有序性的关键方法。在初始化 KeyIterator 时，会将 TreeMap 中包含最小键的 Entry 传给 PrivateEntryIterator。当调用 nextEntry 方法时，通过调用 successor 方法找到当前 entry 的后继，并让 next 指向后继，最后返回当前的 entry。即可实现按正序返回键值的的逻辑。
插入
相对于前两个操作，插入操作明显要复杂一些。当往 TreeMap 中放入新的键值对后，可能会破坏红黑树的性质。这里为了描述方便，把 Entry 称为节点。并把新插入的节点称为N，N 的父节点为P。P 的父节点为G，且 P 是 G 的左孩子。P 的兄弟节点为U。在往红黑树中插入新的节点 N 后（新节点为红色），会产生下面5种情况：
- N 是根节点
- N 的父节点是黑色
- N 的父节点是红色，叔叔节点也是红色
- N 的父节点是红色，叔叔节点是黑色，且 N 是 P 的右孩子
- N 的父节点是红色，叔叔节点是黑色，且 N 是 P 的左孩子
上面5中情况中，情况2不会破坏红黑树性质，所以无需处理。情况1 会破坏红黑树性质2（根是黑色），情况3、4、和5会破坏红黑树性质4（每个红色节点必须有两个黑色的子节点）。这个时候就需要进行调整，以使红黑树重新恢复平衡。接下来分析一下插入操作相关源码：
public V put(K key, V value) {
Entry<K,V> t = root;
// 1.如果根节点为 null，将新节点设为根节点
if (t == null) {
compare(key, key);
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) {
// 2.为 key 在红黑树找到合适的位置
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
} else {
// 与上面代码逻辑类似，省略
}
Entry<K,V> e = new Entry<>(key, value, parent);
// 3.将新节点链入红黑树中
if (cmp < 0)
parent.left = e;
else
parent.right = e;
// 4.插入新节点可能会破坏红黑树性质，这里修正一下
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
put 方法代码如上，逻辑和二叉查找树插入节点逻辑一致。重要的步骤我已经写了注释，并不难理解。插入逻辑的复杂之处在于插入后的修复操作，对应的方法fixAfterInsertion，该方法的源码和说明如下：
到这里，插入操作就讲完了。接下来，来说说 TreeMap 中最复杂的部分，也就是删除操作了。
删除
删除操作是红黑树最复杂的部分，原因是该操作可能会破坏红黑树性质5（从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点），修复性质5要比修复其他性质（性质2和4需修复，性质1和3不用修复）复杂的多。当删除操作导致性质5被破坏时，会出现8种情况。为了方便表述，这里还是先做一些假设。我们把最终被删除的节点称为 X，X 的替换节点称为 N。N 的父节点为P，且 N 是 P 的左孩子。N 的兄弟节点为S，S 的左孩子为 SL，右孩子为 SR。这里特地强调 X 是 最终被删除 的节点，是原因二叉查找树会把要删除有两个孩子的节点的情况转化为删除只有一个孩子的节点的情况，该节点是欲被删除节点的前驱和后继。
接下来，简单列举一下删除节点时可能会出现的情况，先列举较为简单的情况：
- 最终被删除的节点 X 是红色节点
- X 是黑色节点，但该节点的孩子节点是红色
比较复杂的情况：
- 替换节点 N 是新的根
- N 为黑色，N 的兄弟节点 S 为红色，其他节点为黑色。
- N 为黑色，N 的父节点 P，兄弟节点 S 和 S 的孩子节点均为黑色。
- N 为黑色，P 是红色，S 和 S 孩子均为黑色。
- N 为黑色，P 可红可黑，S 为黑色，S 的左孩子 SL 为红色，右孩子 SR 为黑色
- N 为黑色，P 可红可黑，S 为黑色，SR 为红色，SL 可红可黑
上面列举的8种情况中，前两种处理起来比较简单，后6种情况中情况2-6较为复杂，接下来我会对情况2-6展开分析，删除相关的源码如下：
public V remove(Object key) {
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}
private void deleteEntry(Entry<K,V> p) {
modCount++;
size--;
/*
* 1. 如果 p 有两个孩子节点，则找到后继节点，
* 并把后继节点的值复制到节点 P 中，并让 p 指向其后继节点
*/
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) {
/*
* 2. 将 replacement parent 引用指向新的父节点，
* 同时让新的父节点指向 replacement。
*/
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;
// 3. 如果删除的节点 p 是黑色节点，则需要进行调整
if (p.color == BLACK)
fixAfterDeletion(replacement);
} else if (p.parent == null) { // 删除的是根节点，且树中当前只有一个节点
root = null;
} else { // 删除的节点没有孩子节点
// p 是黑色，则需要进行调整
if (p.color == BLACK)
fixAfterDeletion(p);
// 将 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;
}
}
}
从源码中可以看出，remove方法只是一个简单的保证，核心实现在deleteEntry方法中。deleteEntry 主要做了这么几件事：
- 如果待删除节点 P 有两个孩子，则先找到 P 的后继 S，然后将 S 中的值拷贝到 P 中，并让 P 指向 S
- 如果最终被删除节点 P（P 现在指向最终被删除节点）的孩子不为空，则用其孩子节点替换掉
- 如果最终被删除的节点是黑色的话，调用 fixAfterDeletion 方法进行修复
上面说了 replacement 不为空时，deleteEntry 的执行逻辑。上面说的略微啰嗦，如果简单说的话，7个字即可总结：找后继 -> 替换 -> 修复。这三步中，最复杂的是修复操作。修复操作要重新使红黑树恢复平衡，修复操作的源码分析如下：
fixAfterDeletion 方法分析如下：
上面对 fixAfterDeletion 部分代码逻辑就行了分析，通过配图的形式解析了每段代码逻辑所处理的情况。通过图解，应该还是比较好理解的。好了，TreeMap 源码先分析到这里。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
