转自:http://www.fengfly.com/plus/view-213898-10.html
对NavigableMap接口的实现
firstKey()、lastKey()、lowerKey()、higherKey()、ceilingKey()、floorKey();
firstEntry()、 lastEntry()、 lowerEntry()、 higherEntry()、 floorEntry()、 ceilingEntry()、 pollFirstEntry() 、 pollLastEntry();
上面已经讲解过这些API了,下面对其它的API进行说明。
1 反向TreeMap
descendingMap() 的作用是返回当前TreeMap的反向的TreeMap。所谓反向,就是排序顺序和原始的顺序相反。
我们已经知道TreeMap是一颗红黑树,而红黑树是有序的。
TreeMap的排序方式是通过比较器,在创建TreeMap的时候,若指定了比较器,则使用该比较器;否则,就使用Java的默认比较器。
而获取TreeMap的反向TreeMap的原理就是将比较器反向即可!
理解了descendingMap()的反向原理之后,再讲解一下descendingMap()的代码。
- // 获取TreeMap的降序Map
- public NavigableMap<K, V> descendingMap() {
- NavigableMap<K, V> km = descendingMap;
- return (km != null) ? km :
- (descendingMap = new DescendingSubMap(this,
- true, null, true,
- true, null, true));
- }
从中,我们看出descendingMap()实际上是返回DescendingSubMap类的对象。下面,看看DescendingSubMap的源码:
- 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;
- }
- // 获取“子Map”。
- // 范围是从fromKey 到 toKey;fromInclusive是是否包含fromKey的标记,toInclusive是是否包含toKey的标记
- 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);
- }
- // 获取“Map的头部”。
- // 范围从第一个节点 到 toKey, 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);
- }
- // 获取“Map的尾部”。
- // 范围是从 fromKey 到 最后一个节点,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迭代器”
- Iterator<K> descendingKeyIterator() {
- return new SubMapKeyIterator(absLowest(), absHighFence());
- }
- // “降序EntrySet集合”类
- // 实现了iterator()
- final class DescendingEntrySetView extends EntrySetView {
- public Iterator<Map.Entry<K,V>> iterator() {
- return new DescendingSubMapEntryIterator(absHighest(), absLowFence());
- }
- }
- // 返回“降序EntrySet集合”
- public Set<Map.Entry<K,V>> entrySet() {
- EntrySetView es = entrySetView;
- return (es != null) ? es : new DescendingEntrySetView();
- }
- TreeMap.Entry<K,V> subLowest() { return absHighest(); }
- TreeMap.Entry<K,V> subHighest() { return absLowest(); }
- TreeMap.Entry<K,V> subCeiling(K key) { return absFloor(key); }
- TreeMap.Entry<K,V> subHigher(K key) { return absLower(key); }
- TreeMap.Entry<K,V> subFloor(K key) { return absCeiling(key); }
- TreeMap.Entry<K,V> subLower(K key) { return absHigher(key); }
- }
从中,我们看出DescendingSubMap是降序的SubMap,它的实现机制是将“SubMap的比较器反转”。
它继承于NavigableSubMap。而NavigableSubMap是一个继承于AbstractMap的抽象类;它包括2个子类——"(升序)AscendingSubMap"和"(降序)DescendingSubMap"。NavigableSubMap为它的两个子类实现了许多公共API。
下面看看NavigableSubMap的源码。
- static abstract class NavigableSubMap<K,V> extends AbstractMap<K,V>
- implements NavigableMap<K,V>, java.io.Serializable {
- // TreeMap的拷贝
- final TreeMap<K,V> m;
- // lo是“子Map范围的最小值”,hi是“子Map范围的最大值”;
- // loInclusive是“是否包含lo的标记”,hiInclusive是“是否包含hi的标记”
- // fromStart是“表示是否从第一个节点开始计算”,
- // toEnd是“表示是否计算到最后一个节点 ”
- final K lo, hi;
- final boolean fromStart, toEnd;
- final boolean loInclusive, hiInclusive;
- // 构造函数
- NavigableSubMap(TreeMap<K,V> m,
- boolean fromStart, K lo, boolean loInclusive,
- boolean toEnd, K hi, boolean hiInclusive) {
- if (!fromStart && !toEnd) {
- if (m.compare(lo, hi) > 0)
- throw new IllegalArgumentException("fromKey > toKey");
- } else {
- if (!fromStart) // type check
- 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;
- }
- // 判断key是否太小
- final boolean tooLow(Object key) {
- // 若该SubMap不包括“起始节点”,
- // 并且,“key小于最小键(lo)”或者“key等于最小键(lo),但最小键却没包括在该SubMap内”
- // 则判断key太小。其余情况都不是太小!
- if (!fromStart) {
- int c = m.compare(key, lo);
- if (c < 0 || (c == 0 && !loInclusive))
- return true;
- }
- return false;
- }
- // 判断key是否太大
- final boolean tooHigh(Object key) {
- // 若该SubMap不包括“结束节点”,
- // 并且,“key大于最大键(hi)”或者“key等于最大键(hi),但最大键却没包括在该SubMap内”
- // 则判断key太大。其余情况都不是太大!
- if (!toEnd) {
- int c = m.compare(key, hi);
- if (c > 0 || (c == 0 && !hiInclusive))
- return true;
- }
- return false;
- }
- // 判断key是否在“lo和hi”开区间范围内
- final boolean inRange(Object key) {
- return !tooLow(key) && !tooHigh(key);
- }
- // 判断key是否在封闭区间内
- 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);
- }
- // 返回最低的Entry
- final TreeMap.Entry<K,V> absLowest() {
- // 若“包含起始节点”,则调用getFirstEntry()返回第一个节点
- // 否则的话,若包括lo,则调用getCeilingEntry(lo)获取大于/等于lo的最小的Entry;
- // 否则,调用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;
- }
- // 返回最高的Entry
- final TreeMap.Entry<K,V> absHighest() {
- // 若“包含结束节点”,则调用getLastEntry()返回最后一个节点
- // 否则的话,若包括hi,则调用getFloorEntry(hi)获取小于/等于hi的最大的Entry;
- // 否则,调用getLowerEntry(hi)获取大于hi的最大Entry
- TreeMap.Entry<K,V> e =
- 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太小”的情况下,absLowest()返回的Entry才是“大于/等于key的最小Entry”
- // 其它情况下不行。例如,当包含“起始节点”时,absLowest()返回的是最小Entry了!
- 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太小”的情况下,absLowest()返回的Entry才是“大于key的最小Entry”
- // 其它情况下不行。例如,当包含“起始节点”时,absLowest()返回的是最小Entry了,而不一定是“大于key的最小Entry”!
- 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太大”的情况下,(absHighest)返回的Entry才是“小于/等于key的最大Entry”
- // 其它情况下不行。例如,当包含“结束节点”时,absHighest()返回的是最大Entry了!
- if (tooHigh(key))
- return absHighest();
- // 获取"小于/等于key的最大的Entry"
- 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太大”的情况下,(absHighest)返回的Entry才是“小于key的最大Entry”
- // 其它情况下不行。例如,当包含“结束节点”时,absHighest()返回的是最大Entry了,而不一定是“小于key的最大Entry”!
- if (tooHigh(key))
- return absHighest();
- // 获取"小于key的最大的Entry"
- 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方法是需要NavigableSubMap的实现类实现的方法
- 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 Iterator<K> descendingKeyIterator();
- // 返回SubMap是否为空。空的话,返回true,否则返回false
- public boolean isEmpty() {
- return (fromStart && toEnd) ? m.isEmpty() : entrySet().isEmpty();
- }
- // 返回SubMap的大小
- public int size() {
- return (fromStart && toEnd) ? m.size() : entrySet().size();
- }
- // 返回SubMap是否包含键key
- public final boolean containsKey(Object key) {
- return inRange(key) && m.containsKey(key);
- }
- // 将key-value 插入SubMap中
- public final V put(K key, V value) {
- if (!inRange(key))
- throw new IllegalArgumentException("key out of range");
- return m.put(key, value);
- }
- // 获取key对应值
- public final V get(Object key) {
- return !inRange(key)? null : m.get(key);
- }
- // 删除key对应的键值对
- 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的最小键”
- 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的最小键”
- 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的最大键”
- 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的最大键”
- public final K lowerKey(K key) {
- return keyOrNull(subLower(key));
- }
- // 获取"SubMap的第一个键"
- public final K firstKey() {
- return key(subLowest());
- }
- // 获取"SubMap的最后一个键"
- public final K lastKey() {
- return key(subHighest());
- }
- // 获取"SubMap的第一个键值对"
- public final Map.Entry<K,V> firstEntry() {
- return exportEntry(subLowest());
- }
- // 获取"SubMap的最后一个键值对"
- public final Map.Entry<K,V> lastEntry() {
- return exportEntry(subHighest());
- }
- // 返回"SubMap的第一个键值对",并从SubMap中删除改键值对
- 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;
- }
- // 返回"SubMap的最后一个键值对",并从SubMap中删除改键值对
- 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 = null;
- transient EntrySetView entrySetView = null;
- transient KeySet<K> navigableKeySetView = null;
- // 返回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();
- }
- // 排列fromKey(包含) 到 toKey(不包含) 的子map
- public final SortedMap<K,V> subMap(K fromKey, K toKey) {
- return subMap(fromKey, true, toKey, false);
- }
- // 返回当前Map的头部(从第一个节点 到 toKey, 不包括toKey)
- public final SortedMap<K,V> headMap(K toKey) {
- return headMap(toKey, false);
- }
- // 返回当前Map的尾部[从 fromKey(包括fromKeyKey) 到 最后一个节点]
- public final SortedMap<K,V> tailMap(K fromKey) {
- return tailMap(fromKey, true);
- }
- // 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();
- // 若SubMap不是从“开始节点”到“结尾节点”,则调用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);
- }
- // 判断EntrySetView是否包含Object
- public boolean contains(Object o) {
- if (!(o instanceof Map.Entry))
- return false;
- Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
- K key = entry.getKey();
- if (!inRange(key))
- return false;
- TreeMap.Entry node = m.getEntry(key);
- return node != null &&
- valEquals(node.getValue(), entry.getValue());
- }
- // 从EntrySetView中删除Object
- public boolean remove(Object o) {
- if (!(o instanceof Map.Entry))
- return false;
- Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
- K 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;
- }
- }
- // SubMap的迭代器
- abstract class SubMapIterator<T> implements Iterator<T> {
- // 上一次被返回的Entry
- TreeMap.Entry<K,V> lastReturned;
- // 指向下一个Entry
- TreeMap.Entry<K,V> next;
- // “栅栏key”。根据SubMap是“升序”还是“降序”具有不同的意义
- final K fenceKey;
- int expectedModCount;
- // 构造函数
- SubMapIterator(TreeMap.Entry<K,V> first,
- TreeMap.Entry<K,V> fence) {
- // 每创建一个SubMapIterator时,保存修改次数
- // 若后面发现expectedModCount和modCount不相等,则抛出ConcurrentModificationException异常。
- // 这就是所说的fast-fail机制的原理!
- expectedModCount = m.modCount;
- lastReturned = null;
- next = first;
- fenceKey = fence == null ? null : fence.key;
- }
- // 是否存在下一个Entry
- public final boolean hasNext() {
- return next != null && next.key != fenceKey;
- }
- // 返回下一个Entry
- 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指向e的后继节点
- next = successor(e);
- lastReturned = e;
- return e;
- }
- // 返回上一个Entry
- 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指向e的前继节点
- next = predecessor(e);
- lastReturned = e;
- return e;
- }
- // 删除当前节点(用于“升序的SubMap”)。
- // 删除之后,可以继续升序遍历;红黑树特性没变。
- final void removeAscending() {
- if (lastReturned == null)
- throw new IllegalStateException();
- if (m.modCount != expectedModCount)
- throw new ConcurrentModificationException();
- // 这里重点强调一下“为什么当lastReturned的左右孩子都不为空时,要将其赋值给next”。
- // 目的是为了“删除lastReturned节点之后,next节点指向的仍然是下一个节点”。
- // 根据“红黑树”的特性可知:
- // 当被删除节点有两个儿子时。那么,首先把“它的后继节点的内容”复制给“该节点的内容”;之后,删除“它的后继节点”。
- // 这意味着“当被删除节点有两个儿子时,删除当前节点之后,'新的当前节点'实际上是‘原有的后继节点(即下一个节点)’”。
- // 而此时next仍然指向"新的当前节点"。也就是说next是仍然是指向下一个节点;能继续遍历红黑树。
- if (lastReturned.left != null && lastReturned.right != null)
- next = lastReturned;
- m.deleteEntry(lastReturned);
- lastReturned = null;
- expectedModCount = m.modCount;
- }
- // 删除当前节点(用于“降序的SubMap”)。
- // 删除之后,可以继续降序遍历;红黑树特性没变。
- final void removeDescending() {
- if (lastReturned == null)
- throw new IllegalStateException();
- if (m.modCount != expectedModCount)
- throw new ConcurrentModificationException();
- m.deleteEntry(lastReturned);
- lastReturned = null;
- expectedModCount = m.modCount;
- }
- }
- // SubMap的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);
- }
- // 获取下一个节点(升序)
- public Map.Entry<K,V> next() {
- return nextEntry();
- }
- // 删除当前节点(升序)
- public void remove() {
- removeAscending();
- }
- }
- // SubMap的Key迭代器,它只支持升序操作,继承于SubMapIterator
- final class SubMapKeyIterator extends SubMapIterator<K> {
- SubMapKeyIterator(TreeMap.Entry<K,V> first,
- TreeMap.Entry<K,V> fence) {
- super(first, fence);
- }
- // 获取下一个节点(升序)
- public K next() {
- return nextEntry().key;
- }
- // 删除当前节点(升序)
- public void remove() {
- removeAscending();
- }
- }
- // 降序SubMap的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();
- }
- }
- // 降序SubMap的Key迭代器,它只支持降序操作,继承于SubMapIterator
- final class DescendingSubMapKeyIterator extends SubMapIterator<K> {
- DescendingSubMapKeyIterator(TreeMap.Entry<K,V> last,
- TreeMap.Entry<K,V> fence) {
- super(last, fence);
- }
- // 获取下一个节点(降序)
- public K next() {
- return prevEntry().key;
- }
- // 删除当前节点(降序)
- public void remove() {
- removeDescending();
- }
- }
- }
NavigableSubMap源码很多,但不难理解;读者可以通过源码和注释进行理解。
其实,读完NavigableSubMap的源码后,我们可以得出它的核心思想是:它是一个抽象集合类,为2个子类——"(升序)AscendingSubMap"和"(降序)DescendingSubMap"而服务;因为NavigableSubMap实现了许多公共API。它的最终目的是实现下面的一系列函数:
- headMap(K toKey, boolean inclusive)
- headMap(K toKey)
- subMap(K fromKey, K toKey)
- subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
- tailMap(K fromKey)
- tailMap(K fromKey, boolean inclusive)
- navigableKeySet()
- descendingKeySet()