剖析 TreeMap 和 TreeSet
1. 剖析 TreeMap
1.1 TreeMap
TreeMap 首先继承了 AbstractMap 抽象类，表示它具有散列表的性质，也就是由 key-value 组成。其次 TreeMap 实现了 NavigableMap 接口，该接口支持一系列获取指定集合的导航方法，比如获取小于指定key的集合。最后分别实现 Serializable 接口以及 Cloneable 接口，分别表示支持对象序列化以及对象克隆。
TreeMap是基于红黑树实现的有序key-value集合，可以对元素进行自动排序，排序的规则可以是自然排序也可以是实现Comparable接口指定排序方式。
由于红黑树的查找、插入和删除的时间复杂度都是O(logn)，所以TreeMap的查找、插入和删除等操作的时间复杂度也都是O(logn)。相比HashMap，TreeMap的优势是能够自动排序，适合在需要排序的场景下使用。HashMap适合在需要快速查找的场景下使用，而LinkedHashMap适合在即需要快速查找也需要排序的场景下使用。
TreeMap是非线程安全的，若有线程安全问题建议使用ConcurrentSkipListMap代替。它的iterator方法返回的迭代器是fail-fast的。
1.2 实现原理
TreeMap 内部是用红黑树实现的，红黑树是一种大致平衡的排序二叉树。
1.2.1 内部组成
TreeMap内部主要有以下成员：
private final Comparator<? super K> comparator;
private transient Entry<K,V> root;//root指向树的根节点
private transient int size = 0;//当前键值对的个数
private transient int modCount = 0;//记录树结构调整的次数，用来实现Fail-Fast 机制，如果在迭代这些集合的过程中，有其他线程修改了这些集合，就会抛出ConcurrentModificationException异常
//红黑树常量
private static final boolean RED = false;
private static final boolean BLACK = true;
comparator 就是比较器，在构造方法中传递，如果没传，就是 null。Comparator 是用来维护 tree map 集合中的顺序，如果为null，则按照key的自然顺序。Comparator 是一个接口，排序时需要实现其 compare 方法，该方法返回正数，零，负数，它们分别代表大于，等于，小于。
root 指向树的根节点，从根节点可以访问到每个结点，结点的类型为 Entry。Entry 是 TreeMap 的一个内部类，其内部成员和构造方法为：
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;//对于根节点，其父节点为 null
boolean color = BLACK;
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
}
1.2.2 构造方法
TreeMap 中共有四个构造方法，其具体为：
//无参构造方法，将比较器 comparator 置为 null，表示按照key的自然顺序进行排序
public TreeMap() {
comparator = null;
}
//带比较器的构造方法，需要自己实现Comparator
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
//构造包含指定map集合（无序）的元素，并且使用 自然排序 进行插入
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}
/**
* 带SortedMap的构造函数，和上面带Map的构造函数不一样，map是无序的，而SortedMap 是有序的
* 使用 buildFromSorted() 方法将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) {
}
}
1.2.3 保存键值对
底层使用红黑树实现。需要添加元素的时候，这个key-value的元素中的key具备排序能力。因为当向TreeMap中添加元素的时候，需要首先按照key进行排序。如果key不具备排序能力则抛异常。下面我们来看一下添加元素时的源码，如下所示：
public V put(K key, V value) {
Entry<K,V> t = root;
/**
* 如果根节点为空，则新建一个结点，设置 root 指向它，即新添加的元素为根节点
* 并且设置集合的大小 size=1，以及 modCount+1
*/
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;//检测结构性变化
return null;
}
/**
* 如果不是第一次添加元素，则执行以下代码，添加的关键步骤是找寻父节点。
* 寻找父节点根据是否设置了 comparator 分为两种情况
*/
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
//如果设置了 comparator 进行以下操作
if (cpr != null) {
//通过 do-while 循环不断遍历树，调用比较器对key进行比较
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
//遇到key相等，直接将新值覆盖到原值上
return t.setValue(value);
} while (t != null);
//当退出循环时，parent就指向待插结点的父节点
}
//没有 comparator 的情况（新插入的元素，按照key的自然排序）
else {
//如果 key=null，直接抛出异常
//注意：上面构造TreeMap传入了Comparator，是可以允许key为null的
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);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
//调整红黑树的结构，使其符合红黑树的约束，保持大致平衡
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
这里，我们需要注意的是：在添加元素时，如果初始化TreeMap构造函数时，没有传递 Comparator 类，是不允许插入 key 为 null 的键值对的，相反，如果实现了Comparator，则可以传递 key 为 null 的键值对。
另外，上述代码中 compare(key,key)，key 与 key 比较有何意义？我们看compare 方法的代码：
1.2.4 根据键获取值
//就是根据key找到对应的节点p，找到节点后获取值p.value
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
//如果 comparator 不为null，调用单独的getEntryUsingComparator方法
if (comparator != null)
return getEntryUsingComparator(key);
//如果 comparator 为 null（key实现了Comparable接口，使用该接口的compareTo方法进行比较）
//如果 key 为null，抛出异常
if (key == null)
throw new NullPointerException();
//如果 key 不为 null
@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;
}
1.2.5 查看是否包含某个值
TreeMap 可以高效的按键进行查找，但如果要根据值进行查找，则需要遍历，其代码为：
public boolean containsValue(Object value) {
for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e))
//valEquals就是比较值，逐个进行比较
if (valEquals(value, e.value))
return true;
return false;
}
//getFirstEntry 方法返回第一个节点
//第一个节点就是最左边的节点
final Entry<K,V> getFirstEntry() {
Entry<K,V> p = root;
if (p != null)
while (p.left != null)
p = p.left;
return p;
}
//successor方法返回给定节点的后继
static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
if (t == null)
return null;
else if (t.right != null) {//如果当前节点的右子树不为空
Entry<K,V> p = t.right;
while (p.left != null)
p = p.left;
return p;
} else {//如果当前节点的右子树为空
Entry<K,V> p = t.parent;
Entry<K,V> ch = t;
while (p != null && ch == p.right) {
ch = p;
p = p.parent;
}
return p;
}
}
找后继的算法描述为：
（1）如果当前节点有有孩子，则后继结点为右子树中最小的节点
（2）如果当前节点没有右孩子，则其后继结点为该节点的某祖先节点。从当前节点开始向上找，如果它是父节点的右孩子，则继续找父节点，直到它不是右孩子或者父节点为空，第一个非右孩子节点的父亲节点就是后继节点，如果父节点为空，则后继结点为 null。
1.2.6 根据键删除键值对
在删除一个节点的时候，根据节点位置的不同，有不同的删除方法，下面介绍这三种情况：
（1）叶子节点：直接修改父节点对应的引用为 null 即可。
（2）只有一个孩子：在父亲节点和孩子节点之间直接建立链接
（3）有两个孩子：先找到后继节点，找到后，替换当前节点的内容为后继节点，然后再删除后继节点。因为这个后继节点一定没有左孩子，所以就将两个孩子的情况转换成了上面两种情况了。
//根据key找到节点，调用 deleteEntry 删除节点，返回原来的值
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--;
// 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
//在p的父节点和replacement之间建立链接
replacement.parent = p.parent;
if (p.parent == null)//p的父节点为空，则修改root指向新的根
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) { // //如果树中只有一个根节点
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;
}
}
}
1.3 总结
TreeMap 实现了 Map 接口，内部使用红黑树实现，红黑树是统计效率比较高的大致平衡的排序二叉树，这决定了它有如下特点：
（1）按键有序，TreeMap 同样实现了 SortedMap 和 NavigableMap 接口，可以方便的根据键的顺序进行查找，如第一个、最后一个、某一范围的键、临近键等。
（2）为了按键有序，TreeMap 要求键实现 Comparable 接口或者通过构造方法提供一个 Comparator 对象。
（3）根据键保存、查找、删除的效率比较高，为 O(h)，h 为树的高度。
在应用中，如何取舍 HashMap 和 TreeMap 的使用？
不要求排序，优先考虑 HashMap；要求排序，考虑 TreeMap。
2. 剖析TreeSet
HashSet底层是通过HashMap实现的，TreeSet 底层也是通过 TreeMap 实现的。
2.1 TreeSet
TreeSet 的作用是保存无重复的数据，不过还对这些数据进行了排序。TreeMap的底层是通过红黑树实现的，所以TreeSet底层也是通过红黑树实现的。TreeSet 最主要的特点就是对元素进行了排序。我们对其特点进行总结一下：
（1）TreeSet 是基于TreeMap 的 NavigableSet 实现。
（2）TreeSet 的元素存储在 TreeMap 中的 key 中，TreeMap 的 value 是一个常量对象。
（3）非线程安全 。
（4）Java 8 新增分割器 spliterator() 方法。
2.2 实现原理
1.2.1 内部组成
//The backing map
private transient NavigableMap<E,Object> m;//TreeMap实现了NavigableMap接口
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
1.2.2 构造方法
//Constructs a set backed by the specified navigable map
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
/**
Constructs a new, empty tree set, sorted according to the natural ordering of its elements.
All elements inserted into the set must implement the {@link Comparable} interface.
*/
public TreeSet() {
this(new TreeMap<E,Object>());
}
/**
Constructs a new, empty tree set, sorted according to the specified comparator.
All elements inserted into the set must be <i>mutually comparable</i> by the specified comparator
*/
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
1.2.3 添加元素
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
就是调用 map 的 put 方法，元素 e 用作键，值就是固定值 PRESENT，put 返回 null 表示原来没有对应的键，添加成功了。
1.2.4 查看是否包含某个元素
public boolean contains(Object o) {
return m.containsKey(o);
}
就是检查 map 中是否包含对应的键。
1.2.5 删除元素
public boolean remove(Object o) {
return m.remove(o)==PRESENT;
}
调用 map 的 remove 方法，返回值为 PRESENT 表示原来有对应的键且删除成功了。
2.3 总结
在用法方面，它实现了 Set 接口，但有序；在内部实现上，它基于 TreeMap 实现，而 TreeMap 基于红黑树，这决定了它有如下特点：
（1）没有重复元素
（2）添加、删除元素、判断元素是否存在，效率比较高
（3）有序，TreeSet 同样实现了 SortedSet 接口，可以方便的根据顺序进行查找和操作，如第一个、最后一个、某一取值范围、某一值的邻近元素等
（4）为了有序，TreeSet 要求元素实现 Comparable 接口或者 通过构造方法提供一个 Comparator 对象
404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
