java.lang.Object

java.util.AbstractMap<K,V>

java.util.TreeMap<K,V>

类型参数:: K - 此映射维护的键的类型; V - 映射值的类型

所有实现的接口:: Serializable, Cloneable, Map<K,V>, NavigableMap<K,V>, SequencedMap<K,V>, SortedMap<K,V>

public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable

基于红黑树的NavigableMap实现。该映射根据其键的自然顺序或在创建映射时提供的Comparator进行排序，具体取决于使用哪个构造函数。

此实现为containsKey、get、put和remove操作提供了保证的log(n)时间成本。算法是Cormen、Leiserson和Rivest的《算法导论》中的改编。

请注意，由树映射维护的排序，就像任何排序映射一样，无论是否提供了显式比较器，都必须与equals一致，以便此排序映射正确实现Map接口。（有关与equals一致的精确定义，请参见Comparable或Comparator。）这是因为Map接口是根据equals操作定义的，但排序映射使用其compareTo（或compare）方法执行所有键比较，因此通过此方法视为相等的两个键在排序映射的角度来看是相等的。即使其排序与equals不一致，排序映射的行为也是明确定义的；它只是未遵守Map接口的一般契约。

请注意，此实现不是同步的。如果多个线程同时访问映射，并且至少有一个线程在结构上修改了映射，则必须在外部进行同步。（结构修改是添加或删除一个或多个映射的任何操作；仅更改与现有键关联的值不是结构修改。）通常通过对自然封装映射的某个对象进行同步来实现此目的。如果不存在这样的对象，则应使用Collections.synchronizedSortedMap方法“包装”映射。最好在创建时执行此操作，以防止意外的非同步访问映射：

   SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));

通过此类的“集合视图方法”返回的集合的iterator方法返回的迭代器是快速失败的：如果在创建迭代器后的任何时间修改了映射的结构，除非通过迭代器自己的remove方法，否则迭代器将抛出ConcurrentModificationException。因此，在面对并发修改时，迭代器会快速且干净地失败，而不是在未来的不确定时间冒险进行任意的、非确定性的行为。

请注意，迭代器的快速失败行为无法保证，因为一般来说，在存在非同步并发修改的情况下，不可能做出任何硬性保证。快速失败迭代器尽力抛出ConcurrentModificationException。因此，编写依赖此异常正确性的程序是错误的：迭代器的快速失败行为应仅用于检测错误。

方法ceilingEntry(K)、firstEntry()、floorEntry(K)、higherEntry(K)、lastEntry()、lowerEntry(K)、pollFirstEntry()和pollLastEntry()返回代表调用时映射快照的Map.Entry实例。它们不支持通过可选的setValue方法对底层映射进行修改。

此类的putFirst和putLast方法会抛出UnsupportedOperationException。映射的遇到顺序由比较方法确定；因此，不支持显式定位。

此类是Java集合框架的成员。

自 JDK 版本:

1.2

参见:

Nested Class Summary

Nested classes/interfaces declared in class java.util.AbstractMap
AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>
Constructor Summary

Constructors

Constructor

Description

TreeMap()

构造一个新的空树映射，使用其键的自然顺序。

TreeMap(Comparator<? super K> comparator)

构造一个新的空树映射，根据给定的比较器排序。

TreeMap(Map<? extends K,? extends V> m)

构造一个包含与给定映射相同映射的新树映射，根据其键的自然顺序排序。

TreeMap(SortedMap<K,? extends V> m)

构造一个包含与指定排序映射相同映射且使用相同排序的新树映射。
Method Summary

Modifier and Type

Method

Description

Map.Entry<K,V>

ceilingEntry(K key)

返回与大于或等于给定键的最小键关联的键值映射，如果没有这样的键，则返回null。

K

ceilingKey(K key)

返回大于或等于给定键的最小键，如果没有这样的键，则返回null。

void

clear()

从此映射中删除所有映射。

Object

clone()

返回此TreeMap实例的浅拷贝。

Comparator<? super K>

comparator()

返回用于按键排序的比较器，如果此映射使用其键的自然顺序，则返回null。

V

compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)

尝试为指定键及其当前映射值（如果没有当前映射则为null）计算映射。

V

computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)

如果指定键尚未关联到值（或映射到null），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非为null。

V

computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)

如果指定键的值存在且非空，则尝试根据键及其当前映射值计算新映射。

boolean

containsKey(Object key)

如果此映射包含指定键的映射，则返回true。

boolean

containsValue(Object value)

如果此映射将一个或多个键映射到指定值，则返回true。

NavigableSet<K>

descendingKeySet()

返回此映射中包含的键的逆序NavigableSet视图。

NavigableMap<K,V>

descendingMap()

返回此映射中包含的映射的逆序视图。

Set<Map.Entry<K,V>>

entrySet()

返回此映射中包含的映射的Set视图。

Map.Entry<K,V>

firstEntry()

返回此映射中最小键关联的键值映射，如果映射为空，则返回null。

K

firstKey()

返回此映射中当前第一个（最低）键。

Map.Entry<K,V>

floorEntry(K key)

返回与小于或等于给定键的最大键关联的键值映射，如果没有这样的键，则返回null。

K

floorKey(K key)

返回小于或等于给定键的最大键，如果没有这样的键，则返回null。

V

get(Object key)

返回指定键映射到的值，如果此映射不包含键的映射，则返回null。

SortedMap<K,V>

headMap(K toKey)

返回此映射键严格小于toKey的部分视图。

NavigableMap<K,V>

headMap(K toKey, boolean inclusive)

返回此映射键小于（如果inclusive为true，则小于或等于）toKey的部分视图。

Map.Entry<K,V>

higherEntry(K key)

返回与严格大于给定键的最小键关联的键值映射，如果没有这样的键，则返回null。

K

higherKey(K key)

返回严格大于给定键的最小键，如果没有这样的键，则返回null。

Set<K>

keySet()

返回此映射中包含的键的Set视图。

Map.Entry<K,V>

lastEntry()

返回此映射中最大键关联的键值映射，如果映射为空，则返回null。

K

lastKey()

返回此映射中当前最后一个（最高）键。

Map.Entry<K,V>

lowerEntry(K key)

返回与严格小于给定键的最大键关联的键值映射，如果没有这样的键，则返回null。

K

lowerKey(K key)

返回严格小于给定键的最大键，如果没有这样的键，则返回null。

V

merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)

如果指定键尚未关联到值或关联到null，则将其与给定的非空值关联。

NavigableSet<K>

navigableKeySet()

返回此映射中包含的键的NavigableSet视图。

Map.Entry<K,V>

pollFirstEntry()

删除并返回与此映射中最小键关联的键值映射，如果映射为空，则返回null。

Map.Entry<K,V>

pollLastEntry()

删除并返回与此映射中最大键关联的键值映射，如果映射为空，则返回null。

V

put(K key, V value)

在此映射中将指定键与指定值关联。

void

putAll(Map<? extends K,? extends V> map)

将指定映射中的所有映射复制到此映射。

V

putFirst(K k, V v)

抛出UnsupportedOperationException。

V

putLast(K k, V v)

抛出UnsupportedOperationException。

V

remove(Object key)

如果存在，则从此TreeMap中删除此键的映射。

int

size()

返回此映射中键-值映射的数量。

NavigableMap<K,V>

subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)

返回此映射中键范围从fromKey到toKey的部分的视图。

SortedMap<K,V>

subMap(K fromKey, K toKey)

返回此映射中键范围从fromKey（包括）到toKey（不包括）的部分的视图。

SortedMap<K,V>

tailMap(K fromKey)

返回此映射中键大于或等于fromKey的部分的视图。

NavigableMap<K,V>

tailMap(K fromKey, boolean inclusive)

返回此映射中键大于（如果inclusive为true，则为大于或等于）fromKey的部分的视图。

Collection<V>

values()

返回此映射中包含的值的Collection视图。

Methods declared in class java.util.AbstractMap
equals, hashCode, isEmpty, toString

Methods declared in class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods declared in interface java.util.Map
equals, forEach, getOrDefault, hashCode, isEmpty, putIfAbsent, remove, replace, replace, replaceAll

Methods declared in interface java.util.NavigableMap
reversed

Methods declared in interface java.util.SequencedMap
sequencedEntrySet, sequencedKeySet, sequencedValues

Constructor Details
- TreeMap
  
  public TreeMap()
  
  构造一个新的空树映射，使用其键的自然顺序。插入到映射中的所有键都必须实现Comparable接口。此外，所有这些键必须是可相互比较的：对于映射中的任何键k1和k2，k1.compareTo(k2)不能对任何键k1和k2抛出ClassCastException。如果用户尝试将违反此约束的键放入映射中（例如，用户尝试将字符串键放入其键为整数的映射中），则put(Object key, Object value)调用将抛出ClassCastException。
- TreeMap
  
  public TreeMap(Comparator<? super K> comparator)
  
  根据给定的比较器构造一个新的空树映射。插入到映射中的所有键必须由给定比较器相互比较：对于映射中的任何键k1和k2，comparator.compare(k1, k2)不能对任何键k1和k2抛出ClassCastException。如果用户尝试将违反此约束的键放入映射中，则put(Object key, Object value)调用将抛出ClassCastException。
  
  参数:
  
  comparator - 将用于对此映射进行排序的比较器。如果为null，则将使用键的自然顺序。
- TreeMap
  
  public TreeMap(Map<? extends K,? extends V> m)
  
  构造一个包含与给定映射相同映射的新树映射，根据其键的自然顺序排序。插入到新映射中的所有键都必须实现Comparable接口。此外，所有这些键必须是可相互比较的：对于映射中的任何键k1和k2，k1.compareTo(k2)不能对任何键k1和k2抛出ClassCastException。此方法运行时间为n*log(n)。
  
  参数:
  
  m - 要放置在此映射中的映射
  
  抛出:
  
  ClassCastException - 如果m中的键不是Comparable，或者不可相互比较
  
  NullPointerException - 如果指定的映射为null
- TreeMap
  
  public TreeMap(SortedMap<K,? extends V> m)
  
  构造一个包含与指定排序映射相同映射并使用相同排序的新树映射。此方法运行时间为线性时间。
  
  参数:
  
  m - 要放置在此映射中的排序映射，以及要用于对此映射进行排序的比较器
  
  抛出:
  
  NullPointerException - 如果指定的映射为null
Method Details
- size
  
  public int size()
  
  返回此映射中键-值映射的数量。
  
  指定者:
  
  size 在接口 Map<K,V>中
  
  覆盖:
  
  size 在类 AbstractMap<K,V>中
  
  返回:
  
  此映射中键-值映射的数量
- containsKey
  
  public boolean containsKey(Object key)
  
  如果此映射包含指定键的映射，则返回true。
  
  指定者:
  
  containsKey 在接口 Map<K,V>中
  
  覆盖:
  
  containsKey 在类 AbstractMap<K,V>中
  
  参数:
  
  key - 要测试其在此映射中是否存在的键
  
  返回:
  
  如果此映射包含指定键的映射，则返回true
  
  抛出:
  
  ClassCastException - 如果指定的键无法与当前映射中的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然顺序，或者其比较器不允许空键
- containsValue
  
  public boolean containsValue(Object value)
  
  如果此映射将一个或多个键映射到指定值，则返回true。更正式地说，如果此映射包含至少一个映射到值v的键，使得(value==null ? v==null : value.equals(v))，则返回true。对于大多数实现，此操作可能需要与映射大小成线性时间。
  
  指定者:
  
  containsValue 在接口 Map<K,V>中
  
  覆盖:
  
  containsValue 在类 AbstractMap<K,V>中
  
  参数:
  
  value - 要测试其在此映射中是否存在的值
  
  返回:
  
  如果存在映射到value的映射，则返回true；否则返回false
  
  自1.2起:
  
  1.2
- get
  
  public V get(Object key)
  
  返回指定键映射到的值，如果此映射不包含该键的映射，则返回null。
  更正式地说，如果此映射包含从键k到值v的映射，使得根据映射的排序，key等于k，则此方法返回v；否则返回null。（最多可能存在一个这样的映射。）
  
  null的返回值不一定表示映射不包含该键的映射；也可能是映射明确将键映射到null。可以使用containsKey操作来区分这两种情况。
  
  指定者:
  
  get 在接口 Map<K,V>中
  
  覆盖:
  
  get 在类 AbstractMap<K,V>中
  
  参数:
  
  key - 要返回其关联值的键
  
  返回:
  
  指定键映射到的值，如果此映射不包含该键的映射，则返回null
  
  抛出:
  
  ClassCastException - 如果指定的键无法与当前映射中的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然顺序，或者其比较器不允许空键
- comparator
  
  public Comparator<? super K> comparator()
  
  从接口复制的描述: SortedMap
  
  返回用于对此映射中的键进行排序的比较器，如果此映射使用其键的自然顺序，则返回null。
  
  指定者:
  
  comparator 在接口 SortedMap<K,V>中
  
  返回:
  
  用于对此映射中的键进行排序的比较器，如果此映射使用其键的自然顺序，则返回null
- firstKey
  
  public K firstKey()
  
  从接口复制的描述: SortedMap
  
  返回此映射中当前第一个（最低）键。
  
  指定者:
  
  firstKey 在接口 SortedMap<K,V>中
  
  返回值:
  
  当前映射中的第一个（最低）键
  
  抛出:
  
  NoSuchElementException - 如果映射为空
- lastKey
  
  public K lastKey()
  
  从接口中复制的描述: SortedMap
  
  返回当前映射中的最后一个（最高）键。
  
  指定者:
  
  lastKey 在接口 SortedMap<K,V>中
  
  返回值:
  
  当前映射中的最后一个（最高）键
  
  抛出:
  
  NoSuchElementException - 如果映射为空
- putFirst
  
  public V putFirst(K k, V v)
  
  抛出UnsupportedOperationException。由此映射的比较方法引起的遇到顺序决定了映射的位置，因此不支持显式定位。
  
  指定者:
  
  putFirst 在接口 SequencedMap<K,V>中
  
  指定者:
  
  putFirst 在接口 SortedMap<K,V>中
  
  参数:
  
  k - 键
  
  v - 值
  
  返回值:
  
  与k先前关联的值，如果没有则为null
  
  抛出:
  
  UnsupportedOperationException - 总是
  
  自:
  
  21
- putLast
  
  public V putLast(K k, V v)
  
  抛出UnsupportedOperationException。由此映射的比较方法引起的遇到顺序决定了映射的位置，因此不支持显式定位。
  
  指定者:
  
  putLast 在接口 SequencedMap<K,V>中
  
  指定者:
  
  putLast 在接口 SortedMap<K,V>中
  
  参数:
  
  k - 键
  
  v - 值
  
  返回值:
  
  与k先前关联的值，如果没有则为null
  
  抛出:
  
  UnsupportedOperationException - 总是
  
  自:
  
  21
- putAll
  
  public void putAll(Map<? extends K,? extends V> map)
  
  将指定映射中的所有映射复制到此映射。这些映射将替换此映射当前具有的任何键的映射。
  
  指定者:
  
  putAll 在接口 Map<K,V>中
  
  覆盖:
  
  putAll 在类 AbstractMap<K,V>中
  
  参数:
  
  map - 要存储在此映射中的映射
  
  抛出:
  
  ClassCastException - 如果指定映射中键或值的类阻止将其存储在此映射中
  
  NullPointerException - 如果指定映射为null或指定映射包含null键且此映射不允许null键
- put
  
  public V put(K key, V value)
  
  将指定键与指定值关联在此映射中。如果映射先前包含键的映射，则替换旧值。
  
  指定者:
  
  put 在接口 Map<K,V>中
  
  覆盖:
  
  put 在类 AbstractMap<K,V>中
  
  参数:
  
  key - 要关联指定值的键
  
  value - 要与指定键关联的值
  
  返回值:
  
  与key关联的先前值，如果key没有映射则为null。（null返回值也可以表示映射先前将null与key关联。）
  
  抛出:
  
  ClassCastException - 如果指定键无法与当前映射中的键进行比较
  
  NullPointerException - 如果指定键为null且此映射使用自然排序，或其比较器不允许null键
- computeIfAbsent
  
  public V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
  如果指定键尚未关联到值（或映射到null），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非为null。
  如果映射函数返回null，则不记录映射。如果映射函数本身引发（未经检查的）异常，则重新抛出异常，并且不记录映射。最常见的用法是构造作为初始映射值或记忆结果的新对象，如下所示：
  
  map.computeIfAbsent(key, k -> new Value(f(k)));
  
  或者实现多值映射，Map<K,Collection<V>>，支持每个键多个值：
  
  map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
  
  映射函数在计算过程中不应修改此映射。
  
  此方法将尽最大努力，在检测到映射函数在计算过程中修改此映射时，抛出ConcurrentModificationException。
  指定者:
  
  computeIfAbsent 在接口 Map<K,V>中
  
  参数:
  
  key - 要关联指定值的键
  
  mappingFunction - 计算值的映射函数
  
  返回值:
  
  与指定键关联的当前（现有或计算的）值，如果计算的值为null则为null
  
  抛出:
  
  ConcurrentModificationException - 如果检测到映射函数修改了此映射
- computeIfPresent
  
  public V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
  
  如果指定键的值存在且非null，则尝试根据键及其当前映射值计算新映射。
  如果重映射函数返回null，则删除映射。如果重映射函数本身引发（未经检查的）异常，则重新抛出异常，并且当前映射保持不变。
  
  重映射函数在计算过程中不应修改此映射。
  
  此方法将尽最大努力，在检测到重映射函数在计算过程中修改此映射时，抛出ConcurrentModificationException。
  
  指定者:
  
  computeIfPresent 在接口 Map<K,V>中
  
  参数:
  
  key - 要关联指定值的键
  
  remappingFunction - 计算值的重映射函数
  
  返回值:
  
  与指定键关联的新值，如果没有则为null
  
  抛出:
  
  ConcurrentModificationException - 如果检测到重映射函数修改了此映射
- compute
  
  public V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
  尝试计算指定键及其当前映射值（如果没有当前映射值则为null）的映射。例如，要么创建要么追加一个String msg到值映射中：
  map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))
  （对于这种情况，通常更简单的方法是使用方法merge()。）
  如果重新映射函数返回null，则移除映射（如果最初不存在，则保持不存在）。如果重新映射函数本身抛出（未检查的）异常，则重新抛出该异常，并且当前映射保持不变。
  
  在计算过程中，重新映射函数不应修改此映射。
  
  在尽最大努力的基础上，如果检测到重新映射函数在计算过程中修改了此映射，则此方法将抛出ConcurrentModificationException。
  指定者：
  
  compute 在接口 Map<K,V>
  
  参数：
  
  key - 要关联指定值的键
  
  remappingFunction - 用于计算值的重新映射函数
  
  返回：
  
  与指定键关联的新值，如果没有则为null
  
  抛出：
  
  ConcurrentModificationException - 如果检测到重新映射函数修改了此映射
- merge
  
  public V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
  如果指定键尚未与值关联或与null关联，则将其与给定的非null值关联。否则，用给定重新映射函数的结果替换关联值，如果结果为null则移除。当组合多个键的映射值时，此方法可能会有用。例如，要么创建要么追加一个String msg到值映射中：
  map.merge(key, msg, String::concat)
  
  如果重新映射函数返回null，则移除映射。如果重新映射函数本身抛出（未检查的）异常，则重新抛出该异常，并且当前映射保持不变。
  
  在计算过程中，重新映射函数不应修改此映射。
  
  在尽最大努力的基础上，如果检测到重新映射函数在计算过程中修改了此映射，则此方法将抛出ConcurrentModificationException。
  指定者：
  
  merge 在接口 Map<K,V>
  
  参数：
  
  key - 要关联结果值的键
  
  value - 与键关联的现有值合并的非null值，如果与键关联的现有值为null或不存在，则与键关联
  
  remappingFunction - 如果存在，则重新计算值的重新映射函数
  
  返回：
  
  与指定键关联的新值，如果与键关联的值不存在则为null
  
  抛出：
  
  ConcurrentModificationException - 如果检测到重新映射函数修改了此映射
- remove
  
  public V remove(Object key)
  
  如果存在，则从此TreeMap中删除此键的映射。
  
  指定者：
  
  remove 在接口 Map<K,V>
  
  覆盖：
  
  remove 在类 AbstractMap<K,V>
  
  参数：
  
  key - 应删除映射的键
  
  返回：
  
  与key关联的先前值，如果key没有映射则为null。（null返回还可以表示映射先前将null与key关联。）
  
  抛出：
  
  ClassCastException - 如果指定的键无法与当前映射中的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然排序，或其比较器不允许null键
- clear
  
  public void clear()
  
  从此映射中删除所有映射。此调用返回后，映射将为空。
  
  指定者：
  
  clear 在接口 Map<K,V>
  
  覆盖：
  
  clear 在类 AbstractMap<K,V>
- clone
  
  public Object clone()
  
  返回此TreeMap实例的浅拷贝。（键和值本身不会被克隆。）
  覆盖：
  
  clone 在类 AbstractMap<K,V>
  
  返回：
  
  此映射的浅拷贝
  
  参见：
  
  Cloneable
- firstEntry
  
  public Map.Entry<K,V> firstEntry()
  
  从接口复制的描述： NavigableMap
  
  返回与此映射中最小键关联的键值映射，如果映射为空则返回null。
  
  指定者：
  
  firstEntry 在接口 NavigableMap<K,V>
  
  指定者：
  
  firstEntry 在接口 SequencedMap<K,V>
  
  返回：
  
  具有最小键的条目，如果此映射为空则返回null
  
  自：
  
  1.6
- lastEntry
  
  public Map.Entry<K,V> lastEntry()
  
  从接口复制的描述： NavigableMap
  
  返回与此映射中最大键关联的键值映射，如果映射为空则返回null。
  
  指定者：
  
  lastEntry 在接口 NavigableMap<K,V>
  
  指定者：
  
  lastEntry 在接口 SequencedMap<K,V>
  
  返回：
  
  具有最大键的条目，如果此映射为空则返回null
  
  自：
  
  1.6
- pollFirstEntry
  
  public Map.Entry<K,V> pollFirstEntry()
  
  从接口复制的描述： NavigableMap
  
  移除并返回与此映射中最小键关联的键值映射，如果映射为空则返回null。
  
  指定者：
  
  pollFirstEntry 在接口 NavigableMap<K,V>
  
  指定者：
  
  pollFirstEntry 在接口 SequencedMap<K,V>
  
  返回：
  
  此映射的已移除的第一个条目，如果此映射为空则返回null
  
  自：
  
  1.6
- pollLastEntry
  
  public Map.Entry<K,V> pollLastEntry()
  
  从接口复制的描述： NavigableMap
  
  移除并返回与此映射中最大键关联的键值映射，如果映射为空则返回null。
  
  指定者：
  
  pollLastEntry 在接口 NavigableMap<K,V>中
  
  指定者：
  
  pollLastEntry 在接口 SequencedMap<K,V>中
  
  返回值：
  
  如果此映射为空，则返回此映射的最后一个条目，否则返回null
  
  自：
  
  1.6
- lowerEntry
  
  public Map.Entry<K,V> lowerEntry(K key)
  
  从接口复制的描述： NavigableMap
  
  返回与严格小于给定键的最大键关联的键-值映射，如果没有这样的键，则返回null
  
  指定者：
  
  lowerEntry 在接口 NavigableMap<K,V>中
  
  参数：
  
  key - 键
  
  返回值：
  
  具有小于key的最大键的条目，如果没有这样的键，则返回null
  
  抛出：
  
  ClassCastException - 如果指定的键无法与映射中当前的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然排序，或其比较器不允许空键
  
  自：
  
  1.6
- lowerKey
  
  public K lowerKey(K key)
  
  从接口复制的描述： NavigableMap
  
  返回严格小于给定键的最大键，如果没有这样的键，则返回null
  
  指定者：
  
  lowerKey 在接口 NavigableMap<K,V>中
  
  参数：
  
  key - 键
  
  返回值：
  
  小于key的最大键，如果没有这样的键，则返回null
  
  抛出：
  
  ClassCastException - 如果指定的键无法与映射中当前的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然排序，或其比较器不允许空键
  
  自：
  
  1.6
- floorEntry
  
  public Map.Entry<K,V> floorEntry(K key)
  
  从接口复制的描述： NavigableMap
  
  返回与小于或等于给定键的最大键关联的键-值映射，如果没有这样的键，则返回null
  
  指定者：
  
  floorEntry 在接口 NavigableMap<K,V>中
  
  参数：
  
  key - 键
  
  返回值：
  
  具有小于或等于key的最大键的条目，如果没有这样的键，则返回null
  
  抛出：
  
  ClassCastException - 如果指定的键无法与映射中当前的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然排序，或其比较器不允许空键
  
  自：
  
  1.6
- floorKey
  
  public K floorKey(K key)
  
  从接口复制的描述： NavigableMap
  
  返回小于或等于给定键的最大键，如果没有这样的键，则返回null
  
  指定者：
  
  floorKey 在接口 NavigableMap<K,V>中
  
  参数：
  
  key - 键
  
  返回值：
  
  小于或等于key的最大键，如果没有这样的键，则返回null
  
  抛出：
  
  ClassCastException - 如果指定的键无法与映射中当前的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然排序，或其比较器不允许空键
  
  自：
  
  1.6
- ceilingEntry
  
  public Map.Entry<K,V> ceilingEntry(K key)
  
  从接口复制的描述： NavigableMap
  
  返回与大于或等于给定键的最小键关联的键-值映射，如果没有这样的键，则返回null
  
  指定者：
  
  ceilingEntry 在接口 NavigableMap<K,V>中
  
  参数：
  
  key - 键
  
  返回值：
  
  具有大于或等于key的最小键的条目，如果没有这样的键，则返回null
  
  抛出：
  
  ClassCastException - 如果指定的键无法与映射中当前的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然排序，或其比较器不允许空键
  
  自：
  
  1.6
- ceilingKey
  
  public K ceilingKey(K key)
  
  从接口复制的描述： NavigableMap
  
  返回大于或等于给定键的最小键，如果没有这样的键，则返回null
  
  指定者：
  
  ceilingKey 在接口 NavigableMap<K,V>中
  
  参数：
  
  key - 键
  
  返回值：
  
  大于或等于key的最小键，如果没有这样的键，则返回null
  
  抛出：
  
  ClassCastException - 如果指定的键无法与映射中当前的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然排序，或其比较器不允许空键
  
  自：
  
  1.6
- higherEntry
  
  public Map.Entry<K,V> higherEntry(K key)
  
  从接口复制的描述： NavigableMap
  
  返回与严格大于给定键的最小键关联的键-值映射，如果没有这样的键，则返回null
  
  指定者：
  
  higherEntry 在接口 NavigableMap<K,V>中
  
  参数：
  
  key - 键
  
  返回值：
  
  具有大于key的最小键的条目，如果没有这样的键，则返回null
  
  抛出：
  
  ClassCastException - 如果指定的键无法与映射中当前的键进行比较
  
  NullPointerException - 如果指定的键为null且此映射使用自然排序，或其比较器不允许空键
  
  自：
  
  1.6
- higherKey
  
  public K higherKey(K key)
  
  从接口复制的描述： NavigableMap
  
  返回严格大于给定键的最小键，如果没有这样的键，则返回null
  
  指定者：
  
  higherKey 在接口 NavigableMap<K,V>中
  
  参数：
  
  key - 键
  
  返回值：
  
  大于key的最小键，如果没有这样的键则返回null
  
  抛出：
  
  ClassCastException - 如果指定的键无法与当前地图中的键进行比较
  
  NullPointerException - 如果指定的键为null且此地图使用自然排序，或其比较器不允许空键
  
  自1.6版本起：
  
  1.6
- keySet
  
  public Set<K> keySet()
  
  返回此地图中包含的键的Set视图。
  该集合的迭代器以升序返回键。该集合的分割迭代器是延迟绑定、快速失败，并额外报告Spliterator.SORTED和Spliterator.ORDERED，其遇到顺序为升序键顺序。如果树地图的比较器为null，则分割迭代器的比较器（参见Spliterator.getComparator()）为null。否则，分割迭代器的比较器与树地图的比较器相同或施加相同的完全排序。
  
  该集合由地图支持，因此对地图的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改了地图（除非通过迭代器自己的remove操作），则迭代的结果是未定义的。该集合支持元素移除，通过Iterator.remove、Set.remove、removeAll、retainAll和clear操作从地图中删除相应的映射。它不支持add或addAll操作。
  
  指定者：
  
  keySet 在接口 Map<K,V>中
  
  指定者：
  
  keySet 在接口 SortedMap<K,V>中
  
  覆盖：
  
  keySet 在类 AbstractMap<K,V>中
  
  返回值：
  
  包含在此地图中的键的集合视图
- navigableKeySet
  
  public NavigableSet<K> navigableKeySet()
  
  从接口复制的描述： NavigableMap
  
  返回此地图中包含的键的NavigableSet视图。该集合的迭代器以升序返回键。该集合由地图支持，因此对地图的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改了地图（除非通过迭代器自己的 remove操作），则迭代的结果是未定义的。该集合支持元素移除，通过Iterator.remove、Set.remove、removeAll、retainAll和clear操作从地图中删除相应的映射。它不支持add或addAll操作。
  
  指定者：
  
  navigableKeySet 在接口 NavigableMap<K,V>中
  
  返回值：
  
  包含在此地图中的键的可导航集合视图
  
  自1.6版本起：
  
  1.6
- descendingKeySet
  
  public NavigableSet<K> descendingKeySet()
  
  从接口复制的描述： NavigableMap
  
  返回此地图中包含的键的逆序NavigableSet视图。该集合的迭代器以降序返回键。该集合由地图支持，因此对地图的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改了地图（除非通过迭代器自己的 remove操作），则迭代的结果是未定义的。该集合支持元素移除，通过Iterator.remove、Set.remove、removeAll、retainAll和clear操作从地图中删除相应的映射。它不支持add或addAll操作。
  
  指定者：
  
  descendingKeySet 在接口 NavigableMap<K,V>中
  
  返回值：
  
  包含在此地图中的键的逆序可导航集合视图
  
  自1.6版本起：
  
  1.6
- values
  
  public Collection<V> values()
  
  返回此地图中包含的值的Collection视图。
  该集合的迭代器以相应键的升序返回值。该集合的分割迭代器是延迟绑定、快速失败，并额外报告Spliterator.ORDERED，其遇到顺序为相应键的升序。
  
  该集合由地图支持，因此对地图的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改了地图（除非通过迭代器自己的remove操作），则迭代的结果是未定义的。该集合支持元素移除，通过Iterator.remove、Collection.remove、removeAll、retainAll和clear操作从地图中删除相应的映射。它不支持add或addAll操作。
  
  指定者：
  
  values 在接口 Map<K,V>中
  
  指定者：
  
  values 在接口 SortedMap<K,V>中
  
  覆盖：
  
  values 在类 AbstractMap<K,V>中
  
  返回值：
  
  包含在此地图中的值的集合视图
- entrySet
  
  public Set<Map.Entry<K,V>> entrySet()
  
  返回此地图中包含的映射的Set视图。
  该集合的迭代器以升序键顺序返回条目。该集合的分割迭代器是延迟绑定、快速失败，并额外报告Spliterator.SORTED和Spliterator.ORDERED，其遇到顺序为升序键顺序。
  
  该集合由地图支持，因此对地图的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改了地图（除非通过迭代器自己的remove操作，或通过迭代器返回的地图条目上的setValue操作），则迭代的结果是未定义的。该集合支持元素移除，通过Iterator.remove、Set.remove、removeAll、retainAll和clear操作从地图中删除相应的映射。它不支持add或addAll操作。
  
  指定者：
  
  entrySet 在接口 Map<K,V>中
  
  指定者：
  
  entrySet 在接口 SortedMap<K,V>中
  
  返回值：
  
  包含在此地图中的映射的集合视图，按升序键顺序排序
- descendingMap
  
  public NavigableMap<K,V> descendingMap()
  
  从接口复制的描述： NavigableMap
  
  返回此映射中包含的映射的逆序视图。降序映射由此映射支持，因此对映射的更改会反映在降序映射中，反之亦然。如果在对任一映射的集合视图进行迭代时修改了任一映射，迭代的结果是未定义的（除非通过迭代器自己的remove操作）。
  返回的映射具有等效于Collections.reverseOrder(comparator())的排序。表达式m.descendingMap().descendingMap()返回一个与m本质上等效的视图。
  
  指定者：
  
  descendingMap 在接口 NavigableMap<K,V>
  
  返回：
  
  此映射的逆序视图
  
  自：
  
  1.6
- subMap
  
  public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
  
  从接口复制的描述： NavigableMap
  
  返回此映射中键范围从fromKey到toKey的部分视图。如果fromKey和toKey相等，则返回的映射为空，除非fromInclusive和toInclusive都为true。返回的映射由此映射支持，因此返回的映射中的更改会反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。
  如果尝试在其范围之外插入键，或构造一个端点位于其范围之外的子映射，则返回的映射将抛出IllegalArgumentException。
  
  指定者：
  
  subMap 在接口 NavigableMap<K,V>
  
  参数：
  
  fromKey - 返回的映射中键的低端点
  
  fromInclusive - 如果要在返回视图中包含低端点，则为true
  
  toKey - 返回的映射中键的高端点
  
  toInclusive - 如果要在返回视图中包含高端点，则为true
  
  返回：
  
  此映射中键范围从fromKey到toKey的部分视图
  
  抛出：
  
  ClassCastException - 如果无法使用此映射的比较器（或者如果映射没有比较器，则使用自然排序）将fromKey和toKey相互比较。如果fromKey或toKey无法与当前映射中的键进行比较，实现可能会但不一定会抛出此异常。
  
  NullPointerException - 如果fromKey或toKey为null且此映射使用自然排序，或者其比较器不允许空键
  
  IllegalArgumentException - 如果fromKey大于toKey；或者如果此映射本身具有受限范围，并且fromKey或toKey位于范围的边界之外
  
  自：
  
  1.6
- headMap
  
  public NavigableMap<K,V> headMap(K toKey, boolean inclusive)
  
  从接口复制的描述： NavigableMap
  
  返回此映射中键小于（如果inclusive为true，则为小于或等于）toKey的部分视图。返回的映射由此映射支持，因此返回的映射中的更改会反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。
  如果尝试在其范围之外插入键，则返回的映射将抛出IllegalArgumentException。
  
  指定者：
  
  headMap 在接口 NavigableMap<K,V>
  
  参数：
  
  toKey - 返回的映射中键的高端点
  
  inclusive - 如果要在返回视图中包含高端点，则为true
  
  返回：
  
  此映射中键小于（如果inclusive为true，则为小于或等于）toKey的部分视图
  
  抛出：
  
  ClassCastException - 如果toKey与此映射的比较器不兼容（或者如果映射没有比较器，如果toKey未实现Comparable）。实现可能会但不一定会抛出此异常，如果toKey无法与当前映射中的键进行比较。
  
  NullPointerException - 如果toKey为null且此映射使用自然排序，或者其比较器不允许空键
  
  IllegalArgumentException - 如果此映射本身具有受限范围，并且toKey位于范围的边界之外
  
  自：
  
  1.6
- tailMap
  
  public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
  
  从接口复制的描述： NavigableMap
  
  返回此映射中键大于（如果inclusive为true，则为大于或等于）fromKey的部分视图。返回的映射由此映射支持，因此返回的映射中的更改会反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。
  如果尝试在其范围之外插入键，则返回的映射将抛出IllegalArgumentException。
  
  指定者：
  
  tailMap 在接口 NavigableMap<K,V>
  
  参数：
  
  fromKey - 返回的映射中键的低端点
  
  inclusive - 如果要在返回视图中包含低端点，则为true
  
  返回：
  
  此映射中键大于（如果inclusive为true，则为大于或等于）fromKey的部分视图
  
  抛出：
  
  ClassCastException - 如果fromKey与此映射的比较器不兼容（或者如果映射没有比较器，如果fromKey未实现Comparable）。实现可能会但不一定会抛出此异常，如果fromKey无法与当前映射中的键进行比较。
  
  NullPointerException - 如果fromKey为null且此映射使用自然排序，或者其比较器不允许空键
  
  IllegalArgumentException - 如果此映射本身具有受限范围，并且fromKey位于范围的边界之外
  
  自：
  
  1.6
- subMap
  
  public SortedMap<K,V> subMap(K fromKey, K toKey)
  
  从接口复制的描述： NavigableMap
  
  返回此映射中键范围从fromKey（包括）到toKey（不包括）的部分视图。（如果fromKey和toKey相等，则返回的映射为空。）返回的映射由此映射支持，因此返回的映射中的更改会反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。
  如果尝试在其范围之外插入键，则返回的映射将抛出IllegalArgumentException。
  
  等效于subMap(fromKey, true, toKey, false)。
  
  指定者：
  
  subMap 在接口 NavigableMap<K,V>中
  
  指定者：
  
  subMap 在接口 SortedMap<K,V>中
  
  参数：
  
  fromKey - 返回的地图中键的低端点（包含）
  
  toKey - 返回的地图中键的高端点（不包含）
  
  返回：
  
  返回此地图部分的视图，其键范围从fromKey（包含）到toKey（不包含）
  
  抛出：
  
  ClassCastException - 如果无法使用此地图的比较器将fromKey和toKey相互比较（或者，如果地图没有比较器，则使用自然排序）。如果fromKey或toKey无法与地图中当前的键进行比较，实现可以但不是必须抛出此异常。
  
  NullPointerException - 如果fromKey或toKey为null且此地图使用自然排序，或其比较器不允许空键
  
  IllegalArgumentException - 如果fromKey大于toKey；或者如果地图本身具有受限范围，并且fromKey或toKey位于范围的边界之外
- headMap
  
  public SortedMap<K,V> headMap(K toKey)
  
  从接口复制的描述： NavigableMap
  
  返回此地图部分的视图，其键严格小于toKey。返回的地图由此地图支持，因此返回地图中的更改会反映在此地图中，反之亦然。返回的地图支持此地图支持的所有可选地图操作。
  尝试在其范围之外插入键时，返回的地图将抛出IllegalArgumentException。
  
  等效于headMap(toKey, false)。
  
  指定者：
  
  headMap 在接口 NavigableMap<K,V>中
  
  指定者：
  
  headMap 在接口 SortedMap<K,V>中
  
  参数：
  
  toKey - 返回的地图中键的高端点（不包含）
  
  返回：
  
  返回此地图部分的视图，其键严格小于toKey
  
  抛出：
  
  ClassCastException - 如果toKey与此地图的比较器不兼容（或者，如果地图没有比较器，如果toKey未实现Comparable）。如果toKey无法与地图中当前的键进行比较，实现可以但不是必须抛出此异常。
  
  NullPointerException - 如果toKey为null且此地图使用自然排序，或其比较器不允许空键
  
  IllegalArgumentException - 如果地图本身具有受限范围，并且toKey位于范围的边界之外
- tailMap
  
  public SortedMap<K,V> tailMap(K fromKey)
  
  从接口复制的描述： NavigableMap
  
  返回此地图部分的视图，其键大于或等于fromKey。返回的地图由此地图支持，因此返回地图中的更改会反映在此地图中，反之亦然。返回的地图支持此地图支持的所有可选地图操作。
  尝试在其范围之外插入键时，返回的地图将抛出IllegalArgumentException。
  
  等效于tailMap(fromKey, true)。
  
  指定者：
  
  tailMap 在接口 NavigableMap<K,V>中
  
  指定者：
  
  tailMap 在接口 SortedMap<K,V>中
  
  参数：
  
  fromKey - 返回的地图中键的低端点（包含）
  
  返回：
  
  返回此地图部分的视图，其键大于或等于fromKey
  
  抛出：
  
  ClassCastException - 如果fromKey与此地图的比较器不兼容（或者，如果地图没有比较器，如果fromKey未实现Comparable）。如果fromKey无法与地图中当前的键进行比较，实现可以但不是必须抛出此异常。
  
  NullPointerException - 如果fromKey为null且此地图使用自然排序，或其比较器不允许空键
  
  IllegalArgumentException - 如果地图本身具有受限范围，并且fromKey位于范围的边界之外

Class TreeMap<K,V>

Nested Class Summary

Nested classes/interfaces declared in class java.util.AbstractMap

Constructor Summary

Method Summary

Methods declared in class java.util.AbstractMap

Methods declared in class java.lang.Object

Methods declared in interface java.util.Map

Methods declared in interface java.util.NavigableMap

Methods declared in interface java.util.SequencedMap

Constructor Details

TreeMap

TreeMap

TreeMap

TreeMap

Method Details

size

containsKey

containsValue

get

comparator

firstKey

lastKey

putFirst

putLast

putAll

put

computeIfAbsent

computeIfPresent

compute

merge

remove

clear

clone

firstEntry

lastEntry

pollFirstEntry

pollLastEntry

lowerEntry

lowerKey

floorEntry

floorKey

ceilingEntry

ceilingKey

higherEntry

higherKey

keySet

navigableKeySet

descendingKeySet

values

entrySet

descendingMap

subMap

headMap

tailMap

subMap

headMap

tailMap