学新东西必问：有了 HashMap 存储键值对集合，为什么还需要 TreeMap 呢？
- 虽然在 TreeMap 中增删改查时需要log(N)的时间开销，相比 HashMap 的O(1)时间复杂度要差。但 HashMap 的元素顺序是无序的，即时是 LinkedHashMap 也只是提供了添加的顺序存储。
- TreeMap 作为一棵树，天然的具有排序的功能。可以指定 key 按照一定的规则进行存储。不过在添加、修改时也需要一定的调整。
TreeMap 的定义
- 继承了 AbstractMap，实现 NavigableMap，说明拥有更强的元素搜索能力，实现 Cloneable, java.io.Serializable 说明可复制可序列化
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable{}
1.1 TreeMap 的构造函数
- TreeMap 总共有四个构造函数，用于指定排序方式 与 初始化集合
/* 空构造：元素使用自然排序 */
public TreeMap() {
comparator = null;
}
/* 指定元素排序方式 */
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
/* 初始化集合，元素使用自然排序方式 */
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}
/* 初始化集合，使用原集合已有的排序方式 */
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 TreeMap 的属性
/* 万年不变版本号 */
private static final long serialVersionUID = 919286545866124006L;
/* 排序规则 */
private final Comparator<? super K> comparator;
/* 根节点 */
private transient Entry<K,V> root;
/* 元素个数 */
private transient int size = 0;
/* 修改版本 */
private transient int modCount = 0;
/* 键值对集合 */
private transient EntrySet entrySet;
/* 具备导航功能的 key 值集合，提供 >= > <= < 等方法 */
private transient KeySet<K> navigableKeySet;
/* 倒序的map */
private transient NavigableMap<K,V> descendingMap;
/* subMap使用，作为 fenceKey 与 null 区分 */
private static final Object UNBOUNDED = new Object();
/* 节点颜色 */
private static final boolean RED = false;
private static final boolean BLACK = true;
1.3 内部类
1.3.1 Entry<K,V>
- 相当于 HashMap 中的 Node，用来存储数据的节点
static final class Entry<K,V> implements Map.Entry<K,V> {
K key; // key 值
V value; // value 值
Entry<K,V> left; // 左节点
Entry<K,V> right; // 右节点
Entry<K,V> parent; // 父节点
boolean color = BLACK; // 节点颜色，默认为黑色 true，RED 为 false
/* 新建节点，需要提供 key,value, parent(没有为 null) */
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
/* 返回当前节点的 key 值 */
public K getKey() {
return key;
}
/* 返回当前节点的 value 值 */
public V getValue() {
return value;
}
/* 修改当前节点的值，返回旧值 */
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
/* 判断对象o 与否与 当前节点相等 */
public boolean equals(Object o) {
/* 是否为 Map.Entry 的实例 */
if (!(o instanceof Map.Entry))
return false;
/* 类型强转后拿到 key，value 进行判断 */
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
}
/* 重写 HashCode */
public int hashCode() {
int keyHash = (key==null ? 0 : key.hashCode());
int valueHash = (value==null ? 0 : value.hashCode());
return keyHash ^ valueHash;
}
/* 重写 toString */
public String toString() {
return key + "=" + value;
}
}
1.3.2 Values
- value 值的集合
class Values extends AbstractCollection<V> {
/* 获取一个 value 值的迭代器 */
public Iterator<V> iterator() {
/* getFirstEntry() 获取最左元素，即最小元素 */
return new ValueIterator(getFirstEntry());
}
/* value 值的个数，底层调用 TreeMap 的元素个数 */
public int size() {
return TreeMap.this.size();
}
/* 是否包含指定的 value */
public boolean contains(Object o) {
return TreeMap.this.containsValue(o);
}
/* 移除指定的value 对应的 entry */
public boolean remove(Object o) {
/* 从最小节点getFirstEntry()开始遍历，successor(e) 获取后继节点 */
for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e)) {
/* 判断相等则 删除该 entry节点 */
if (valEquals(e.getValue(), o)) {
deleteEntry(e);
return true;
}
}
/* 找不到节点返回false */
return false;
}
/* 清空 values，相当于清空 TreeMap */
public void clear() {
TreeMap.this.clear();
}
/* 获取一个 value值的分解迭代器 */
public Spliterator<V> spliterator() {
return new ValueSpliterator<K,V>(TreeMap.this, null, null, 0, -1, 0);
}
}
1.3.3 ValueIterator
- values 的迭代器
/* 继承 PrivateEntryIterator */
final class ValueIterator extends PrivateEntryIterator<V> {
/* 构造函数需要出传入首元素 */
ValueIterator(Entry<K,V> first) {
super(first);
}
/* 获取下一个值 */
public V next() {
return nextEntry().value;
}
}
1.3.4 ValueSpliterator
- value 值的分解迭代器，继承 TreeMapSpliterator
static final class ValueSpliterator<K,V>
extends TreeMapSpliterator<K,V>
implements Spliterator<V> {
/* tree：操作的树，origin: 起始节点，fence: 终止位置(不包含)
* side：分解的中间位置，est:元素的大致个数，expectedModCount: 期待的修改版本 */
ValueSpliterator(TreeMap<K,V> tree,
TreeMap.Entry<K,V> origin, TreeMap.Entry<K,V> fence,
int side, int est, int expectedModCount) {
super(tree, origin, fence, side, est, expectedModCount);
}
/* 分解方法 */
public ValueSpliterator<K,V> trySplit() {
/* 还没有进行初始化 */
if (est < 0)
getEstimate();
int d = side; // 默认 0
TreeMap.Entry<K,V> e = current, f = fence,
s = ((e == null || e == f) ? null : // e 为null || e == f 元素个数较少
(d == 0) ? tree.root : // root 节点处分割
(d > 0) ? e.right : // 右节点处分割
(d < 0 && f != null) ? f.left : // 左节点处分割
null);
/* s 为 null || s == 起始节点 e || s == 末尾节点f || e.key >= s.key 没必要进行分解操作 */
if (s != null && s != e && s != f &&
/* 这里什么时候会出现 >= 0，待我知道再回来 */
tree.compare(e.key, s.key) < 0) {
side = 1;
return new ValueSpliterator<>
(tree, e, current = s, -1, est >>>= 1, expectedModCount);
}
return null;
}
/* 遍历当前未遍历的元素，执行指定的 action 动作 */
public void forEachRemaining(Consumer<? super V> action) {
/* null 异常检测 */
if (action == null)
throw new NullPointerException();
/* 还未进行初始化 */
if (est < 0)
getEstimate();
TreeMap.Entry<K,V> f = fence, e, p, pl;
if ((e = current) != null && e != f) {
current = f; // exhaust
do {
action.accept(e.value);
/* 因为从最左子节点开始遍历，所有这里找到右子节点的最左节点 */
if ((p = e.right) != null) {
while ((pl = p.left) != null)
p = pl;
}
else {
/* 检测是否为右节点返回的父节点，若为true，表示该节点已经遍历过 */
while ((p = e.parent) != null && e == p.right)
e = p;
}
} while ((e = p) != null && e != f);
/* modCount 修改版本检测 */
if (tree.modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/* 执行一次 action 动作， */
public boolean tryAdvance(Consumer<? super V> action) {
TreeMap.Entry<K,V> e;
/* null 异常检测 */
if (action == null)
throw new NullPointerException();
/* 还未进行初始化 */
if (est < 0)
getEstimate(); // force initialization
if ((e = current) == null || e == fence)
return false;
/* 当前节点赋值为 后继节点 */
current = successor(e);
action.accept(e.value);
/* modCount 修改版本检测 */
if (tree.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
/* 特征值 */
public int characteristics() {
return (side == 0 ? Spliterator.SIZED : 0) | Spliterator.ORDERED;
}
}
1.3.5 KeySet< E >
- 键值集合，继承了 NavigableSet。
- NavigableSet 扩展了 SortedSet，具有了为给定搜索目标报告最接近匹配项的导航方法。
- NavigableMap 扩展了 SortedMap，具有了针对给定搜索目标返回最接近匹配项的导航方法。
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();
}
/* 降序迭代器，不同类型返回不同的迭代器 */
public Iterator<E> descendingIterator() {
if (m instanceof TreeMap)
return ((TreeMap<E,?>)m).descendingKeyIterator();
else
return ((TreeMap.NavigableSubMap<E,?>)m).descendingKeyIterator();
}
/* 元素个数 */
public int size() { return m.size(); }
/* 是否为空 */
public boolean isEmpty() { return m.isEmpty(); }
/* 是否包含指定对象 */
public boolean contains(Object o) { return m.containsKey(o); }
/* 清空元素 */
public void clear() { m.clear(); }
/* 返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。 */
public E lower(E e) { return m.lowerKey(e); }
/* 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。 */
public E floor(E e) { return m.floorKey(e); }
/* 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。 */
public E ceiling(E e) { return m.ceilingKey(e); }
/* 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。 */
public E higher(E e) { return m.higherKey(e); }
/* 获取第一个（最低）元素 */
public E first() { return m.firstKey(); }
/* 获取最后一个（最高）元素 */
public E last() { return m.lastKey(); }
/* 获取当前的比较器 */
public Comparator<? super E> comparator() { return m.comparator(); }
/* 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。 */
public E pollFirst() {
Map.Entry<E,?> e = m.pollFirstEntry();
return (e == null) ? null : e.getKey();
}
/* 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。 */
public E pollLast() {
Map.Entry<E,?> e = m.pollLastEntry();
return (e == null) ? null : e.getKey();
}
/* 移除指定的元素 */
public boolean remove(Object o) {
int oldSize = size();
m.remove(o);
return size() != oldSize;
}
/* 返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。 */
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
E toElement, boolean toInclusive) {
return new KeySet<>(m.subMap(fromElement, fromInclusive,
toElement, toInclusive));
}
/* 返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement */
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
return new KeySet<>(m.headMap(toElement, inclusive));
}
/* 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement */
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
return new KeySet<>(m.tailMap(fromElement, inclusive));
}
/* 返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括） */
public SortedSet<E> subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
/* 返回此 set 的部分视图，其元素严格小于 toElement */
public SortedSet<E> headSet(E toElement) {
return headSet(toElement, false);
}
/* 返回此 set 的部分视图，其元素大于等于 fromElement */
public SortedSet<E> tailSet(E fromElement) {
return tailSet(fromElement, true);
}
/* 返回此 set 中所包含元素的逆序视图 */
public NavigableSet<E> descendingSet() {
return new KeySet<>(m.descendingMap());
}
/* 获取一个分解遍历器 */
public Spliterator<E> spliterator() {
return keySpliteratorFor(m);
}
}
1.3.6 KeyIterator
- key 值的遍历器，继承 PrivateEntryIterator
final class KeyIterator extends PrivateEntryIterator<K> {
/* 传入第一个元素(最小元素) */
KeyIterator(Entry<K,V> first) {
super(first);
}
/* 返回下一个遍历的 key 值 */
public K next() {
return nextEntry().key;
}
}
1.3.7 KeySpliterator
- key 值的分解遍历器，继续 TreeMapSpliterator
static final class KeySpliterator<K,V>
extends TreeMapSpliterator<K,V>
implements Spliterator<K> {
/* tree：操作的树，origin: 起始节点，fence: 终止位置(不包含)
* side：分解的中间位置，est:元素的大致个数，expectedModCount: 期待的修改版本 */
KeySpliterator(TreeMap<K,V> tree,
TreeMap.Entry<K,V> origin, TreeMap.Entry<K,V> fence,
int side, int est, int expectedModCount) {
super(tree, origin, fence, side, est, expectedModCount);
}
/* 分解迭代器方法 */
public KeySpliterator<K,V> trySplit() {
/* 还未进行初始化 */
if (est < 0)
getEstimate();
int d = side;
/* 获取当前分解遍历器的起始与终止位置 */
TreeMap.Entry<K,V> e = current, f = fence,
/* 判断分解的中间位置 */
s = ((e == null || e == f) ? null : // e 为null || e == f 元素个数较少
(d == 0) ? tree.root : // root 节点处分割
(d > 0) ? e.right : // 右节点处分割
(d < 0 && f != null) ? f.left : // 左节点处分割
null);
/* s 为 null || s 为起始节点 e || s 为末尾节点f || e.key >= s.key 没必要进行操作 */
if (s != null && s != e && s != f &&
/* 这里什么时候会出现 >= 0，待我知道再回来 */
tree.compare(e.key, s.key) < 0) {
side = 1;
return new KeySpliterator<>
(tree, e, current = s, -1, est >>>= 1, expectedModCount);
}
return null;
}
/* 遍历未进行遍历的元素，执行 action 动作 */
public void forEachRemaining(Consumer<? super K> action) {
/* null 异常检测 */
if (action == null)
throw new NullPointerException();
/* 为进行初始化 */
if (est < 0)
getEstimate();
TreeMap.Entry<K,V> f = fence, e, p, pl;
current = f;
do {
/* 执行 action 动作后，e 赋值为后继节点 */
action.accept(e.key);
if ((p = e.right) != null) {
while ((pl = p.left) != null)
p = pl;
}
else {
while ((p = e.parent) != null && e == p.right)
e = p;
}
} while ((e = p) != null && e != f);
/* 修改版本检测 */
if (tree.modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/* 未遍历的第一个元素进行 action 动作 */
public boolean tryAdvance(Consumer<? super K> action) {
TreeMap.Entry<K,V> e;
/* null 异常检测 */
if (action == null)
throw new NullPointerException();
/* 为进行初始化 */
if (est < 0)
getEstimate();
/* 没有元素可遍历 返回 null */
if ((e = current) == null || e == fence)
return false;
/* 当前节点置为后继节点 */
current = successor(e);
/* 执行 action 动作 */
action.accept(e.key);
/* 修改版本检测 */
if (tree.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
/* 返回特征值 */
public int characteristics() {
return (side == 0 ? Spliterator.SIZED : 0) |
Spliterator.DISTINCT | Spliterator.SORTED | Spliterator.ORDERED;
}
/* 获取比较器 */
public final Comparator<? super K> getComparator() {
return tree.comparator;
}
}
1.3.8 EntrySet
- 键值对集合
class EntrySet extends AbstractSet<Map.Entry<K,V>> {
/* 获取键值对的迭代器 */
public Iterator<Map.Entry<K,V>> iterator() {
return new EntryIterator(getFirstEntry());
}
/* 是否包含指定的对象o */
public boolean contains(Object o) {
/* 是否为 Map.Entry 的实例 */
if (!(o instanceof Map.Entry))
return false;
/* 获取 key,value 进行比较 */
Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
Object value = entry.getValue();
Entry<K,V> p = getEntry(entry.getKey());
return p != null && valEquals(p.getValue(), value);
}
/* 移除指定的对象o */
public boolean remove(Object o) {
/* 是否为 Map.Entry 的实例 */
if (!(o instanceof Map.Entry))
return false;
/* 找到 key 对应的 entry节点，找到则删除返回true，找不到返回false */
Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
Object value = entry.getValue();
Entry<K,V> p = getEntry(entry.getKey());
if (p != null && valEquals(p.getValue(), value)) {
deleteEntry(p);
return true;
}
return false;
}
/* 元素个数 */
public int size() {
return TreeMap.this.size();
}
/* 清空键值对，即清空TreeMap */
public void clear() {
TreeMap.this.clear();
}
/* 获取一个分解迭代器 */
public Spliterator<Map.Entry<K,V>> spliterator() {
return new EntrySpliterator<K,V>(TreeMap.this, null, null, 0, -1, 0);
}
}
1.3.9 EntryIterator
- 键值对迭代器， 继承 PrivateEntryIterator
final class EntryIterator extends PrivateEntryIterator<Map.Entry<K,V>> {
/* 初始化第一个元素(最小元素) */
EntryIterator(Entry<K,V> first) {
super(first);
}
/* 获取下一个遍历的元素 */
public Map.Entry<K,V> next() {
return nextEntry();
}
}
1.3.10 EntrySpliterator
- 键值对的分解迭代器，继承 TreeMapSpliterator
static final class EntrySpliterator<K,V>
extends TreeMapSpliterator<K,V>
implements Spliterator<Map.Entry<K,V>> {
/* tree：操作的树，origin: 起始节点，fence: 终止位置(不包含)
* side：分解的中间位置，est:元素的大致个数，expectedModCount: 期待的修改版本 */
EntrySpliterator(TreeMap<K,V> tree,
TreeMap.Entry<K,V> origin, TreeMap.Entry<K,V> fence,
int side, int est, int expectedModCount) {
super(tree, origin, fence, side, est, expectedModCount);
}
/* 分解方法 */
public EntrySpliterator<K,V> trySplit() {
/* 还未进行初始化 */
if (est < 0)
getEstimate();
int d = side;
/* 获取当前分解遍历器的起始与终止位置 */
TreeMap.Entry<K,V> e = current, f = fence,
/* 判断分解的中间位置 */
s = ((e == null || e == f) ? null : // e 为null || e == f 元素个数较少
(d == 0) ? tree.root : // root 节点处分割
(d > 0) ? e.right : // 右节点处分割
(d < 0 && f != null) ? f.left : // 左节点处分割
null);
if (s != null && s != e && s != f &&
/* 这里什么时候会出现 >= 0，待我知道再回来 */
tree.compare(e.key, s.key) < 0) { // e not already past s
side = 1;
return new EntrySpliterator<>
(tree, e, current = s, -1, est >>>= 1, expectedModCount);
}
return null;
}
/* 遍历未遍历的元素，执行指定的 action 动作 */
public void forEachRemaining(Consumer<? super Map.Entry<K, V>> action) {
/* null 异常检测 */
if (action == null)
throw new NullPointerException();
/* 未进行初始化 */
if (est < 0)
getEstimate();
TreeMap.Entry<K,V> f = fence, e, p, pl;
if ((e = current) != null && e != f) {
current = f;
do {
action.accept(e);
if ((p = e.right) != null) {
while ((pl = p.left) != null)
p = pl;
}
else {
while ((p = e.parent) != null && e == p.right)
e = p;
}
} while ((e = p) != null && e != f);
/* modCount 修改版本检测 */
if (tree.modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/* 获取第一个未遍历的元素，执行指定的 action 动作 */
public boolean tryAdvance(Consumer<? super Map.Entry<K,V>> action) {
TreeMap.Entry<K,V> e;
if (action == null)
throw new NullPointerException();
if (est < 0)
getEstimate(); // force initialization
if ((e = current) == null || e == fence)
return false;
/* 当前节点赋值为 e 的后继节点 */
current = successor(e);
action.accept(e);
/* 修改版本检测 */
if (tree.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
/* 返回特征值 */
public int characteristics() {
return (side == 0 ? Spliterator.SIZED : 0) |
Spliterator.DISTINCT | Spliterator.SORTED | Spliterator.ORDERED;
}
/* 获取比较器，判断比较器是否为空，为 null 创建一个比较器返回，不为 null 返回该比较器 */
@Override
public Comparator<Map.Entry<K, V>> getComparator() {
if (tree.comparator != null) {
return Map.Entry.comparingByKey(tree.comparator);
}
else {
return (Comparator<Map.Entry<K, V>> & Serializable) (e1, e2) -> {
@SuppressWarnings("unchecked")
Comparable<? super K> k1 = (Comparable<? super K>) e1.getKey();
return k1.compareTo(e2.getKey());
};
}
}
}
1.3.11 PrivateEntryIterator
- 私有键值对迭代器，是 TreeMap 中 KeyIterator，ValueIterator，EntryIterator，DescendingKeyIterator 迭代器的父类
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;
}
/* 判断是否有下一个节点，以 next 指针作为判断 */
public final boolean hasNext() {
return next != null;
}
/* 获取下一个节点 */
final Entry<K,V> nextEntry() {
Entry<K,V> e = next;
/* null 异常检测，所以建议使用hasNext 是否有下一个节点 */
if (e == null)
throw new NoSuchElementException();
/* 修改版本检测 */
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
/* next 指向后继节点 */
next = successor(e);
lastReturned = e;
return e;
}
/* 获取前一个节点(逆序时使用，实际上可以看做获取下一个节点) */
final Entry<K,V> prevEntry() {
Entry<K,V> e = next;
/* null 异常检测 */
if (e == null)
throw new NoSuchElementException();
/* 修改版本检测 */
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
/* */
next = predecessor(e);
lastReturned = e;
return e;
}
/* 移除最后返回的节点(即当前遍历的节点) */
public void remove() {
/* null 异常检测 */
if (lastReturned == null)
throw new IllegalStateException();
/* 修改版本检测 */
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
/* 左右节点不为空，删除的肯定是替代节点 */
if (lastReturned.left != null && lastReturned.right != null)
next = lastReturned;
deleteEntry(lastReturned);
/* 更新修改版本 */
expectedModCount = modCount;
lastReturned = null;
}
}
1.3.12 TreeMapSpliterator
- KeySpliterator，ValueSpliterator，EntrySpliterator，DescendingKeySpliterator 分解迭代器的父类
static class TreeMapSpliterator<K,V> {
final TreeMap<K,V> tree; // 分解的树
TreeMap.Entry<K,V> current; // 当前节点，默认为 first(最小节点)
TreeMap.Entry<K,V> fence; // 分解的最后节点(不包括)，默认为 null
int side; // 0: root节点分割, -1: 左节点分割, +1: 右节点分割，默认为0
int est; // 大致个数，初始为-1表示该迭代器正序删除，-2表示逆序
int expectedModCount; // 期待版本
/* 初始化各种书写 */
TreeMapSpliterator(TreeMap<K,V> tree,
TreeMap.Entry<K,V> origin, TreeMap.Entry<K,V> fence,
int side, int est, int expectedModCount) {
this.tree = tree;
this.current = origin;
this.fence = fence;
this.side = side;
this.est = est;
this.expectedModCount = expectedModCount;
}
/* 获取大致个数，调用此方法会强制初始化 */
final int getEstimate() { // force initialization
int s; TreeMap<K,V> t;
/* est < 0 即尚未进行初始化 */
if ((s = est) < 0) {
/* 树若为空，没有节点 */
if ((t = tree) != null) {
/* s为 -1 表示正序， -2 表示逆序 */
current = (s == -1) ? t.getFirstEntry() : t.getLastEntry();
/* 大致的个数为 树的节点个数 */
s = est = t.size;
expectedModCount = t.modCount;
}
else
s = est = 0;
}
return s;
}
/* 返回大致个数 */
public final long estimateSize() {
return (long)getEstimate();
}
}
1.3.13 DescendingKeyIterator
- 逆序的 key值迭代器，继承 PrivateEntryIterator
final class DescendingKeyIterator extends PrivateEntryIterator<K> {
/* 因为是逆序，会传入最后一个元素(最大元素) */
DescendingKeyIterator(Entry<K,V> first) {
super(first);
}
/* 获取下一个元素，底层调用 prevEntry() 获取前一个元素 */
public K next() {
return prevEntry().key;
}
/* 删除当前遍历的节点 */
public void remove() {
if (lastReturned == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
deleteEntry(lastReturned);
lastReturned = null;
expectedModCount = modCount;
}
}
1.3.14 DescendingKeySpliterator
- 逆序 key 值分解迭代器，继承 DescendingKeySpliterator
static final class DescendingKeySpliterator<K,V>
extends TreeMapSpliterator<K,V>
implements Spliterator<K> {
/* 构造函数，初始化各种属性 */
DescendingKeySpliterator(TreeMap<K,V> tree,
TreeMap.Entry<K,V> origin, TreeMap.Entry<K,V> fence,
int side, int est, int expectedModCount) {
super(tree, origin, fence, side, est, expectedModCount);
}
/* 分解方法 */
public DescendingKeySpliterator<K,V> trySplit() {
/* 还未进行初始化 */
if (est < 0)
getEstimate();
int d = side;
TreeMap.Entry<K,V> e = current, f = fence,
s = ((e == null || e == f) ? null : // e 为null || e == f 元素个数较少
(d == 0) ? tree.root : // root 节点处分割
(d > 0) ? e.right : // 右节点处分割
(d < 0 && f != null) ? f.left : // 左节点处分割
null);
/* s 为 null || s == 起始节点 e || s == 末尾节点f || e.key >= s.key 没必要进行分解操作 */
if (s != null && s != e && s != f &&
/* 这里什么时候会出现 >= 0，待我知道再回来 */
tree.compare(e.key, s.key) > 0) { // e not already past s
side = 1;
return new DescendingKeySpliterator<>
(tree, e, current = s, -1, est >>>= 1, expectedModCount);
}
return null;
}
/* 遍历未遍历的节点，执行指定的 action 动作 */
public void forEachRemaining(Consumer<? super K> action) {
if (action == null)
throw new NullPointerException();
if (est < 0)
getEstimate();
TreeMap.Entry<K,V> f = fence, e, p, pr;
if ((e = current) != null && e != f) {
current = f; // exhaust
do {
action.accept(e.key);
if ((p = e.left) != null) {
while ((pr = p.right) != null)
p = pr;
}
else {
while ((p = e.parent) != null && e == p.left)
e = p;
}
} while ((e = p) != null && e != f);
if (tree.modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
/* 未遍历第一个元素执行指定的 action 动作 */
public boolean tryAdvance(Consumer<? super K> action) {
TreeMap.Entry<K,V> e;
if (action == null)
throw new NullPointerException();
if (est < 0)
getEstimate(); // force initialization
if ((e = current) == null || e == fence)
return false;
current = predecessor(e);
action.accept(e.key);
if (tree.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
/* 返回特征值 */
public int characteristics() {
return (side == 0 ? Spliterator.SIZED : 0) |
Spliterator.DISTINCT | Spliterator.ORDERED;
}
}
1.3.15 SubMap
- 仅为了兼容以前的版本支持序列化使用
private class SubMap extends AbstractMap<K,V>
implements SortedMap<K,V>, java.io.Serializable {
private static final long serialVersionUID = -6520786458950516097L;
private boolean fromStart = false, toEnd = false;
private K fromKey, toKey;
private Object readResolve() {
return new AscendingSubMap<>(TreeMap.this,
fromStart, fromKey, true,
toEnd, toKey, false);
}
public Set<Map.Entry<K,V>> entrySet() { throw new InternalError(); }
public K lastKey() { throw new InternalError(); }
public K firstKey() { throw new InternalError(); }
public SortedMap<K,V> subMap(K fromKey, K toKey) { throw new InternalError(); }
public SortedMap<K,V> headMap(K toKey) { throw new InternalError(); }
public SortedMap<K,V> tailMap(K fromKey) { throw new InternalError(); }
public Comparator<? super K> comparator() { throw new InternalError(); }
}
1.3.16 NavigableSubMap
- 子串map集合
abstract static class NavigableSubMap<K,V> extends AbstractMap<K,V>
implements NavigableMap<K,V>, java.io.Serializable {
private static final long serialVersionUID = -2102997345730753016L;
// 操作的集合
final TreeMap<K,V> m;
// lo: 最小的key值，hi: 最大的key值
final K lo, hi;
// fromStart：是否从第一个节点开始计算，toEnd：是否计算到最后一个节点
final boolean fromStart, toEnd;
// loInclusive:是否包含 lo，hiInclusive:是否包含 hi
final boolean loInclusive, hiInclusive;
NavigableSubMap(TreeMap<K,V> m,
boolean fromStart, K lo, boolean loInclusive,
boolean toEnd, K hi, boolean hiInclusive) {
/* 没有从头开始或者到尾结束，检查 lo 与 hi 的大小关系 */
if (!fromStart && !toEnd) {
if (m.compare(lo, hi) > 0)
throw new IllegalArgumentException("fromKey > toKey");
} else {
/* 类型检查 */
if (!fromStart)
m.compare(lo, lo);
if (!toEnd)
m.compare(hi, hi);
}
/* 属性赋值 */
this.m = m;
this.fromStart = fromStart;
this.lo = lo;
this.loInclusive = loInclusive;
this.toEnd = toEnd;
this.hi = hi;
this.hiInclusive = hiInclusive;
}
// internal utilities
/* 指定的 key 是否太小 */
final boolean tooLow(Object key) {
/* 非 从头开始 */
if (!fromStart) {
/* key < lo || key == lo 但map不包含lo */
int c = m.compare(key, lo);
if (c < 0 || (c == 0 && !loInclusive))
return true;
}
return false;
}
/* 指定的 key 是否太大 */
final boolean tooHigh(Object key) {
/* 非 包含至尾部 */
if (!toEnd) {
/* key > hi || key == hi 但map不包含 hi */
int c = m.compare(key, hi);
if (c > 0 || (c == 0 && !hiInclusive))
return true;
}
return false;
}
/* 是否在 map 开区间范围内 */
final boolean inRange(Object key) {
return !tooLow(key) && !tooHigh(key);
}
/* 是否在 map 闭区间范围内 */
final boolean inClosedRange(Object key) {
return (fromStart || m.compare(key, lo) >= 0)
&& (toEnd || m.compare(hi, key) >= 0);
}
/* 判断key是否在区间内, inclusive是区间开关标志 */
final boolean inRange(Object key, boolean inclusive) {
return inclusive ? inRange(key) : inClosedRange(key);
}
/*
* Absolute versions of relation operations.
* Subclasses map to these using like-named "sub"
* versions that invert senses for descending maps
*/
/* 返回最小的节点 */
final TreeMap.Entry<K,V> absLowest() {
/* 从头开始，获取第一个节点
* 包含lo，调用getCeilingEntry(lo)获取大于或等于lo的最小的Entry
* 不包含lo，调用getHigherEntry(lo)获取大于lo的最小Entry */
TreeMap.Entry<K,V> e =
(fromStart ? m.getFirstEntry() :
(loInclusive ? m.getCeilingEntry(lo) :
m.getHigherEntry(lo)));
return (e == null || tooHigh(e.key)) ? null : e;
}
/* 返回最大的节点 */
final TreeMap.Entry<K,V> absHighest() {
/* 包含结束节点，获取最后一个节点
* 包含hi，调用getFloorEntry(hi)获取小于或等于hi的最大的Entry
* 不包含hi，调用getLowerEntry(hi)获取小于hi的最大的Entry */
TreeMap.Entry<K,V> e =
(toEnd ? m.getLastEntry() :
(hiInclusive ? m.getFloorEntry(hi) :
m.getLowerEntry(hi)));
return (e == null || tooLow(e.key)) ? null : e;
}
/* 返回 >= key的最小的Entry */
final TreeMap.Entry<K,V> absCeiling(K key) {
/* 若该key太小，返回最小的节点 */
if (tooLow(key))
return absLowest();
/* 获取 >= key的最小Entry */
TreeMap.Entry<K,V> e = m.getCeilingEntry(key);
return (e == null || tooHigh(e.key)) ? null : e;
}
/* 返回 > key的最小的Entry */
final TreeMap.Entry<K,V> absHigher(K key) {
/* 若该key太小，返回最小的节点 */
if (tooLow(key))
return absLowest();
/* 获取 > key的最小Entry */
TreeMap.Entry<K,V> e = m.getHigherEntry(key);
return (e == null || tooHigh(e.key)) ? null : e;
}
/* 返回小于等于key的最大的Entry */
final TreeMap.Entry<K,V> absFloor(K key) {
/* 若该key太，返回最小的节点 */
if (tooHigh(key))
return absHighest();
TreeMap.Entry<K,V> e = m.getFloorEntry(key);
return (e == null || tooLow(e.key)) ? null : e;
}
/* 返回小于key的最大的Entry */
final TreeMap.Entry<K,V> absLower(K key) {
/* 若该key太，返回最小的节点 */
if (tooHigh(key))
return absHighest();
TreeMap.Entry<K,V> e = m.getLowerEntry(key);
return (e == null || tooLow(e.key)) ? null : e;
}
/* 返回大于最大节点中的最小节点 ，不存在的话，返回null */
final TreeMap.Entry<K,V> absHighFence() {
return (toEnd ? null : (hiInclusive ?
m.getHigherEntry(hi) :
m.getCeilingEntry(hi)));
}
/* 返回小于最小节点中的最大节点，不存在的话，返回null */
final TreeMap.Entry<K,V> absLowFence() {
return (fromStart ? null : (loInclusive ?
m.getLowerEntry(lo) :
m.getFloorEntry(lo)));
}
/* 留给子类实现的抽象方法 */
abstract TreeMap.Entry<K,V> subLowest();
abstract TreeMap.Entry<K,V> subHighest();
abstract TreeMap.Entry<K,V> subCeiling(K key);
abstract TreeMap.Entry<K,V> subHigher(K key);
abstract TreeMap.Entry<K,V> subFloor(K key);
abstract TreeMap.Entry<K,V> subLower(K key);
abstract Iterator<K> keyIterator();
abstract Spliterator<K> keySpliterator();
abstract Iterator<K> descendingKeyIterator();
// public 方法
/* 当前 map 是否为空 */
public boolean isEmpty() {
/* 包含头尾则表示map没有被截取过，调用treeMap的方法，否则调用 subMap的方法 */
return (fromStart && toEnd) ? m.isEmpty() : entrySet().isEmpty();
}
/* 返回元素个数 */
public int size() {
/* 包含头尾则表示map没有被截取过，调用treeMap的方法，否则调用 subMap的方法 */
return (fromStart && toEnd) ? m.size() : entrySet().size();
}
/* 是否包含指定的key */
public final boolean containsKey(Object key) {
/* 是否在范围内，是的话在查找是否存在 */
return inRange(key) && m.containsKey(key);
}
/* 添加节点 */
public final V put(K key, V value) {
if (!inRange(key))
throw new IllegalArgumentException("key out of range");
return m.put(key, value);
}
/* 获取节点的value值，找不到返回 null */
public final V get(Object key) {
return !inRange(key) ? null : m.get(key);
}
/* 移除节点，返回该value值 */
public final V remove(Object key) {
return !inRange(key) ? null : m.remove(key);
}
/* 获取 >= key的最小节点 */
public final Map.Entry<K,V> ceilingEntry(K key) {
return exportEntry(subCeiling(key));
}
/* 获取 >= key的最小key */
public final K ceilingKey(K key) {
return keyOrNull(subCeiling(key));
}
/* 获取 > key的最小节点 */
public final Map.Entry<K,V> higherEntry(K key) {
return exportEntry(subHigher(key));
}
/* 获取 > key的最小key */
public final K higherKey(K key) {
return keyOrNull(subHigher(key));
}
/* 获取 <= key的最小节点 */
public final Map.Entry<K,V> floorEntry(K key) {
return exportEntry(subFloor(key));
}
/* 获取 < key的最小key */
public final K floorKey(K key) {
return keyOrNull(subFloor(key));
}
/* 获取 < key的最小节点 */
public final Map.Entry<K,V> lowerEntry(K key) {
return exportEntry(subLower(key));
}
/* 获取 < key的最小key */
public final K lowerKey(K key) {
return keyOrNull(subLower(key));
}
/* 获取当前map第一个key */
public final K firstKey() {
return key(subLowest());
}
/* 获取当前map最后一个key */
public final K lastKey() {
return key(subHighest());
}
/* 获取当前map第一个节点 */
public final Map.Entry<K,V> firstEntry() {
return exportEntry(subLowest());
}
/* 获取当前map最后一个节点 */
public final Map.Entry<K,V> lastEntry() {
return exportEntry(subHighest());
}
/* 获取并弹出当前map第一个节点 */
public final Map.Entry<K,V> pollFirstEntry() {
TreeMap.Entry<K,V> e = subLowest();
Map.Entry<K,V> result = exportEntry(e);
if (e != null)
m.deleteEntry(e);
return result;
}
/* 获取并弹出当前map最后一个节点 */
public final Map.Entry<K,V> pollLastEntry() {
TreeMap.Entry<K,V> e = subHighest();
Map.Entry<K,V> result = exportEntry(e);
if (e != null)
m.deleteEntry(e);
return result;
}
// Views
transient NavigableMap<K,V> descendingMapView;
transient EntrySetView entrySetView;
transient KeySet<K> navigableKeySetView;
/* 返回NavigableSet对象，实际上返回的是当前对象的 Key值集合 */
public final NavigableSet<K> navigableKeySet() {
KeySet<K> nksv = navigableKeySetView;
return (nksv != null) ? nksv :
(navigableKeySetView = new TreeMap.KeySet<>(this));
}
/* 返回 key值集合 */
public final Set<K> keySet() {
return navigableKeySet();
}
/* 返回逆序的key值集合 */
public NavigableSet<K> descendingKeySet() {
return descendingMap().navigableKeySet();
}
/* 获取子串map，包头不包尾 */
public final SortedMap<K,V> subMap(K fromKey, K toKey) {
return subMap(fromKey, true, toKey, false);
}
/* 返回从头到toKey的子串map */
public final SortedMap<K,V> headMap(K toKey) {
return headMap(toKey, false);
}
/* 返回从fromKey到尾的子串map */
public final SortedMap<K,V> tailMap(K fromKey) {
return tailMap(fromKey, true);
}
// View classes： NavigableSubMap 的内部类
/* Map的Entry的集合 */
abstract class EntrySetView extends AbstractSet<Map.Entry<K,V>> {
private transient int size = -1, sizeModCount;
/* 获取EntrySet的大小 */
public int size() {
/* 若SubMap是从“开始节点”到“结尾节点”，则SubMap大小就是原TreeMap的大小 */
if (fromStart && toEnd)
return m.size();
/* 调用iterator()遍历EntrySetView中的元素 */
if (size == -1 || sizeModCount != m.modCount) {
sizeModCount = m.modCount;
size = 0;
Iterator<?> i = iterator();
while (i.hasNext()) {
size++;
i.next();
}
}
return size;
}
/* 判断EntrySetView是否为空 */
public boolean isEmpty() {
TreeMap.Entry<K,V> n = absLowest();
return n == null || tooHigh(n.key);
}
/* 是否包含对象o */
public boolean contains(Object o) {
/* 是否为 Map.Entry的实例 */
if (!(o instanceof Map.Entry))
return false;
/* 强转类型后获取key,value 进行比较 */
Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
Object key = entry.getKey();
if (!inRange(key))
return false;
TreeMap.Entry<?,?> node = m.getEntry(key);
return node != null &&
valEquals(node.getValue(), entry.getValue());
}
/* 删除节点 */
public boolean remove(Object o) {
/* 是否为 Map.Entry的实例 */
if (!(o instanceof Map.Entry))
return false;
/* 强转类型后获取key,value 进行比较，相等则进行删除 */
Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
Object key = entry.getKey();
if (!inRange(key))
return false;
TreeMap.Entry<K,V> node = m.getEntry(key);
if (node!=null && valEquals(node.getValue(),
entry.getValue())) {
m.deleteEntry(node);
return true;
}
return false;
}
}
/* map 的迭代器 */
abstract class SubMapIterator<T> implements Iterator<T> {
TreeMap.Entry<K,V> lastReturned; // 最后返回的节点
TreeMap.Entry<K,V> next; // 下一个返回的节点
final Object fenceKey; // 截取的最大key值(不包含)
int expectedModCount; // 期待的修改版本
/* 构造器：初始化属性 */
SubMapIterator(TreeMap.Entry<K,V> first,
TreeMap.Entry<K,V> fence) {
expectedModCount = m.modCount;
lastReturned = null;
next = first;
fenceKey = fence == null ? UNBOUNDED : fence.key;
}
/* 是否有下一个节点 */
public final boolean hasNext() {
return next != null && next.key != fenceKey;
}
/* 获取下一个节点 */
final TreeMap.Entry<K,V> nextEntry() {
TreeMap.Entry<K,V> e = next;
if (e == null || e.key == fenceKey)
throw new NoSuchElementException();
if (m.modCount != expectedModCount)
throw new ConcurrentModificationException();
next = successor(e);// next 设置为后继节点
lastReturned = e;
return e;
}
/* 获取前一个节点，倒序遍历时使用 */
final TreeMap.Entry<K,V> prevEntry() {
TreeMap.Entry<K,V> e = next;
if (e == null || e.key == fenceKey)
throw new NoSuchElementException();
if (m.modCount != expectedModCount)
throw new ConcurrentModificationException();
next = predecessor(e);// next 设置为前置节点
lastReturned = e;
return e;
}
/* 删除节点，用于升序 */
final void removeAscending() {
if (lastReturned == null)
throw new IllegalStateException();
if (m.modCount != expectedModCount)
throw new ConcurrentModificationException();
// deleted entries are replaced by their successors
if (lastReturned.left != null && lastReturned.right != null)
next = lastReturned;
m.deleteEntry(lastReturned);
lastReturned = null;
expectedModCount = m.modCount;
}
/* 删除节点，用于降序 */
/* 这里为什么不用 next = lastReturned; 因为红黑树删除的是替代节点，
又使用的是后继节点替代，所有不影响逆序遍历的 next 指针 */
final void removeDescending() {
if (lastReturned == null)
throw new IllegalStateException();
if (m.modCount != expectedModCount)
throw new ConcurrentModificationException();
m.deleteEntry(lastReturned);
lastReturned = null;
expectedModCount = m.modCount;
}
}
/* 升序的子串Entry迭代器，继承SubMapIterator */
final class SubMapEntryIterator extends SubMapIterator<Map.Entry<K,V>> {
/*构造器：指定截取范围 */
SubMapEntryIterator(TreeMap.Entry<K,V> first,
TreeMap.Entry<K,V> fence) {
super(first, fence);
}
/* 获取下一个节点，底层调用父类的nextEntry */
public Map.Entry<K,V> next() {
return nextEntry();
}
/* 调用升序的删除节点 */
public void remove() {
removeAscending();
}
}
/* 降序的子串Entry迭代器，继承SubMapIterator */
final class DescendingSubMapEntryIterator extends SubMapIterator<Map.Entry<K,V>> {
/* 构造器：指定截取范围 */
DescendingSubMapEntryIterator(TreeMap.Entry<K,V> last,
TreeMap.Entry<K,V> fence) {
super(last, fence);
}
/* 调用父类的前序遍历方法 */
public Map.Entry<K,V> next() {
return prevEntry();
}
public void remove() {
removeDescending();
}
}
// 子串key的迭代器，继承SubMapIterator
final class SubMapKeyIterator extends SubMapIterator<K>
implements Spliterator<K> {
/* 构造器：指定截取范围 */
SubMapKeyIterator(TreeMap.Entry<K,V> first,
TreeMap.Entry<K,V> fence) {
super(first, fence);
}
/* 获取下一个key值 */
public K next() {
return nextEntry().key;
}
/* 删除key值 */
public void remove() {
removeAscending();
}
/* 分解方法，直接返回null */
public Spliterator<K> trySplit() {
return null;
}
/* 循环遍历未遍历的key，执行action 动作 */
public void forEachRemaining(Consumer<? super K> action) {
while (hasNext())
action.accept(next());
}
/* 获取第一个未遍历的key，执行action 动作 */
public boolean tryAdvance(Consumer<? super K> action) {
if (hasNext()) {
action.accept(next());
return true;
}
return false;
}
/* 获取map大致个数，直接返回 Long 的最大值 */
public long estimateSize() {
return Long.MAX_VALUE;
}
/* 返回特征值 */
public int characteristics() {
return Spliterator.DISTINCT | Spliterator.ORDERED |
Spliterator.SORTED;
}
/* 获取比较器 */
public final Comparator<? super K> getComparator() {
return NavigableSubMap.this.comparator();
}
}
/* 降序的key值迭代器 */
final class DescendingSubMapKeyIterator extends SubMapIterator<K>
implements Spliterator<K> {
/* 构造器：指定截取范围 */
DescendingSubMapKeyIterator(TreeMap.Entry<K,V> last,
TreeMap.Entry<K,V> fence) {
super(last, fence);
}
/* 获取下一个key值 */
public K next() {
return prevEntry().key;
}
/* 删除key值 */
public void remove() {
removeDescending();
}
/* 分解方法，直接返回null */
public Spliterator<K> trySplit() {
return null;
}
/* 循环遍历未遍历的key，执行action 动作 */
public void forEachRemaining(Consumer<? super K> action) {
while (hasNext())
action.accept(next());
}
/* 获取第一个未遍历的key，执行action 动作 */
public boolean tryAdvance(Consumer<? super K> action) {
if (hasNext()) {
action.accept(next());
return true;
}
return false;
}
/* 获取map大致个数，直接返回 Long 的最大值 */
public long estimateSize() {
return Long.MAX_VALUE;
}
/* 返回特征值 */
public int characteristics() {
return Spliterator.DISTINCT | Spliterator.ORDERED;
}
}
}
1.3.17 AscendingSubMap
- 升序的子串map，继承 NavigableSubMap
static final class AscendingSubMap<K,V> extends NavigableSubMap<K,V> {
private static final long serialVersionUID = 912986545866124060L;
/* 构造方法：指定各种属性 */
AscendingSubMap(TreeMap<K,V> m,
boolean fromStart, K lo, boolean loInclusive,
boolean toEnd, K hi, boolean hiInclusive) {
super(m, fromStart, lo, loInclusive, toEnd, hi, hiInclusive);
}
/* 获取比较器 */
public Comparator<? super K> comparator() {
return m.comparator();
}
/* 截取 fromKey ~ toKey 的子串，fromInclusive、toInclusive判断是否闭区间 */
public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
K toKey, boolean toInclusive) {
if (!inRange(fromKey, fromInclusive))
throw new IllegalArgumentException("fromKey out of range");
if (!inRange(toKey, toInclusive))
throw new IllegalArgumentException("toKey out of range");
return new AscendingSubMap<>(m,
false, fromKey, fromInclusive,
false, toKey, toInclusive);
}
/* 获取头结点~ toKey的子串map， inclusive：是否包含toKey */
public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
if (!inRange(toKey, inclusive))
throw new IllegalArgumentException("toKey out of range");
return new AscendingSubMap<>(m,
fromStart, lo, loInclusive,
false, toKey, inclusive);
}
/* 获取fromKey~ 尾节点的子串map， inclusive：是否包含fromKey*/
public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
if (!inRange(fromKey, inclusive))
throw new IllegalArgumentException("fromKey out of range");
return new AscendingSubMap<>(m,
false, fromKey, inclusive,
toEnd, hi, hiInclusive);
}
/* 获取降序map */
public NavigableMap<K,V> descendingMap() {
NavigableMap<K,V> mv = descendingMapView;
return (mv != null) ? mv :
(descendingMapView =
new DescendingSubMap<>(m,
fromStart, lo, loInclusive,
toEnd, hi, hiInclusive));
}
/* key值迭代器 */
Iterator<K> keyIterator() {
return new SubMapKeyIterator(absLowest(), absHighFence());
}
/* key值 分解迭代器 */
Spliterator<K> keySpliterator() {
return new SubMapKeyIterator(absLowest(), absHighFence());
}
/* 倒序key值迭代器 */
Iterator<K> descendingKeyIterator() {
return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
}
/* 升序键值对视图 */
final class AscendingEntrySetView extends EntrySetView {
public Iterator<Map.Entry<K,V>> iterator() {
return new SubMapEntryIterator(absLowest(), absHighFence());
}
}
/* 键值对集合 */
public Set<Map.Entry<K,V>> entrySet() {
EntrySetView es = entrySetView;
return (es != null) ? es : (entrySetView = new AscendingEntrySetView());
}
/* 最大节点 */
TreeMap.Entry<K,V> subLowest() { return absLowest(); }
/* 最小节点 */
TreeMap.Entry<K,V> subHighest() { return absHighest(); }
/* 返回 >= key的最小的Entry */
TreeMap.Entry<K,V> subCeiling(K key) { return absCeiling(key); }
/* 返回 > key的最小的Entry */
TreeMap.Entry<K,V> subHigher(K key) { return absHigher(key); }
/* 返回 <= key的最大的Entry */
TreeMap.Entry<K,V> subFloor(K key) { return absFloor(key); }
/* 返回 < key的最大的Entry */
TreeMap.Entry<K,V> subLower(K key) { return absLower(key); }
}
1.3.18 DescendingSubMap
- 降序的子串map
static final class DescendingSubMap<K,V> extends NavigableSubMap<K,V> {
private static final long serialVersionUID = 912986545866120460L;
/* 构造方法：指定各种属性 */
DescendingSubMap(TreeMap<K,V> m,
boolean fromStart, K lo, boolean loInclusive,
boolean toEnd, K hi, boolean hiInclusive) {
super(m, fromStart, lo, loInclusive, toEnd, hi, hiInclusive);
}
private final Comparator<? super K> reverseComparator =
Collections.reverseOrder(m.comparator);
/* 获取比较器 */
public Comparator<? super K> comparator() {
return reverseComparator;
}
/* 截取 fromKey ~ toKey 的子串，fromInclusive、toInclusive判断是否闭区间 */
public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
K toKey, boolean toInclusive) {
if (!inRange(fromKey, fromInclusive))
throw new IllegalArgumentException("fromKey out of range");
if (!inRange(toKey, toInclusive))
throw new IllegalArgumentException("toKey out of range");
return new DescendingSubMap<>(m,
false, toKey, toInclusive,
false, fromKey, fromInclusive);
}
/* 获取头结点~ toKey的子串map， inclusive：是否包含toKey */
public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
if (!inRange(toKey, inclusive))
throw new IllegalArgumentException("toKey out of range");
return new DescendingSubMap<>(m,
false, toKey, inclusive,
toEnd, hi, hiInclusive);
}
/* 获取fromKey~ 尾节点的子串map， inclusive：是否包含fromKey*/
public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
if (!inRange(fromKey, inclusive))
throw new IllegalArgumentException("fromKey out of range");
return new DescendingSubMap<>(m,
fromStart, lo, loInclusive,
false, fromKey, inclusive);
}
/* 获取升序map */
public NavigableMap<K,V> descendingMap() {
NavigableMap<K,V> mv = descendingMapView;
return (mv != null) ? mv :
(descendingMapView =
new AscendingSubMap<>(m,
fromStart, lo, loInclusive,
toEnd, hi, hiInclusive));
}
/* key值迭代器 */
Iterator<K> keyIterator() {
return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
}
/* key值 分解迭代器 */
Spliterator<K> keySpliterator() {
return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
}
/* 升序key值迭代器 */
Iterator<K> descendingKeyIterator() {
return new SubMapKeyIterator(absLowest(), absHighFence());
}
/* 降序键值对视图 */
final class DescendingEntrySetView extends EntrySetView {
public Iterator<Map.Entry<K,V>> iterator() {
return new DescendingSubMapEntryIterator(absHighest(), absLowFence());
}
}
/* 键值对集合 */
public Set<Map.Entry<K,V>> entrySet() {
EntrySetView es = entrySetView;
return (es != null) ? es : (entrySetView = new DescendingEntrySetView());
}
/* 最大节点 */
TreeMap.Entry<K,V> subLowest() { return absLowest(); }
/* 最小节点 */
TreeMap.Entry<K,V> subHighest() { return absHighest(); }
/* 返回 >= key的最小的Entry */
TreeMap.Entry<K,V> subCeiling(K key) { return absCeiling(key); }
/* 返回 > key的最小的Entry */
TreeMap.Entry<K,V> subHigher(K key) { return absHigher(key); }
/* 返回 <= key的最大的Entry */
TreeMap.Entry<K,V> subFloor(K key) { return absFloor(key); }
/* 返回 < key的最大的Entry */
TreeMap.Entry<K,V> subLower(K key) { return absLower(key); }
}
总结
- TreeMap 使用 Entry 存储节点信息，使用NavigableMap为寻找节点提供一系列的查找方法，使得查找节点时变得简单、方便。
- 与 hashMap 一样具有key,value,entry的迭代器与分解迭代器，还提供了子串SubMap截取的一系列方法，使得长map可以分解成多条子串map。
2537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
