TreeMap (Java Platform SE 8 )

java.lang.Object
- java.util.AbstractMap<K,V>
- - java.util.TreeMap<K,V>

参数类型

K -钥匙的Map保持型

V -映射的值的类型

All Implemented Interfaces:

Serializable， Cloneable， Map < k，v >，< > NavigableMap K，V， SortedMap < k，v >
```
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, Serializable
```
基于 NavigableMap实现红黑树。Map是根据它的键的 natural ordering排序，或通过设置在Map创建时 Comparator，取决于使用哪个构造函数。
这种实现提供保证log（n）的时间成本的containsKey，get，put和remove操作。算法是在Cormen，Leiserson改编，和Rivest的算法导论。

注意排序树映射保持，像任何排序图，以及是否提供一个明确的比较器，必须符合等于如果排序图是正确执行Map接口。（见Comparable或Comparator为符合平等的。一个精确的定义）这是因为Map接口在equals操作定义，但排序图上执行所有关键的比较使用compareTo（或compare）方法，所以两个键被视为平等的方法是，从排序Map的角度来看，平等。即使它的顺序是不一致的equals排序图的行为是明确的；它只是不服从的Map接口一般合同。

请注意，此实现不同步。如果多个线程访问一个Map的同时，并至少有一个线程修改Map的结构，它必须是同步的外部。（结构上的修改是任何操作，添加或删除一个或多个映射；仅仅改变一个现有的键所关联的值不是一个结构上的修改。）这通常是由一些对象同步自然封装图完成。如果该对象不存在，Map应该是“包裹”使用Collections.synchronizedSortedMap方法。最好的做法是在创建时，防止意外的非同步访问的Map：
```
M =集合建模。synchronizedsortedmap（新的树状图（…））；
```
迭代器返回的集合的iterator方法返回这个类的所有的“集合视图的方法“快速失败：如果Map的结构修改，迭代器创建后的任何时间，以任何方式除了通过迭代器的remove方法，迭代器将抛出一个ConcurrentModificationException。因此，在遇到同步修改，迭代器不能快速、干净，而不是冒着任意的，非在将来一个不确定的时间确定的行为。

注意迭代器不能快速失败行为得到保证的话，一般来说，不可能在不同步的并发修改的存在作出难以保证。快速失败迭代器扔ConcurrentModificationException尽最大努力的基础上。因此，要写一个程序，依靠这一例外的正确性错误：快速失败迭代器的行为只能用来检测错误。

对所有Map.Entry返回这类及其观点方法代表快照映射在当时产生的。他们不支持Entry.setValue方法。（注意，可以在相关的Map使用put。变化映射）

这个班的一员 Java Collections Framework。
从以下版本开始：

一点二

另请参见：

Map， HashMap， Hashtable， Comparable， Comparator， Collection， Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class java.util.AbstractMap
  AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>

构造方法摘要

构造方法
Constructor and Description
`TreeMap()` 构造一个新的，空的树映射，使用它的键的自然顺序。
`TreeMap(Comparator<? super K> comparator)` 构造一个新的，空的树映射，根据给定的比较器排序。
`TreeMap(Map<? extends K,? extends V> m)` 构造了一个包含相同映射的新的树映射，根据它的键的自然顺序排列。
`TreeMap(SortedMap<K,? extends V> m)` 构造一个包含相同映射的新树映射，并使用指定的排序映射使用相同的排序。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`Map.Entry<K,V>`	`ceilingEntry(K key)` 返回的键值映射与最关键的大于或等于给定的键，或 `null`如果没有这样的关键。
`K`	`ceilingKey(K key)` 最关键的收益大于或等于给定的键，或 `null`如果没有这样的关键。
`void`	`clear()` 从这个映射中移除所有的映射。
`Object`	`clone()` 返回该 `TreeMap`实例浅拷贝。
`Comparator<? super K>`	`comparator()` 返回用于秩序在这个Map钥匙的比较器，或 `null`如果这个Map使用其密钥的 natural ordering。
`boolean`	`containsKey(Object key)` 返回 `true`如果这Map包含一个指定的键映射。
`boolean`	`containsValue(Object value)` 返回 `true`如果映射到指定的值的一个或多个键。
`NavigableSet<K>`	`descendingKeySet()` 返回一个相反的顺序 `NavigableSet`查看键包含在这个Map。
`NavigableMap<K,V>`	`descendingMap()` 返回此映射中包含的映射的逆顺序视图。
`Set<Map.Entry<K,V>>`	`entrySet()` 返回一个 `Set`映射的视图包含在这个Map。
`Map.Entry<K,V>`	`firstEntry()` 返回一个与该图的最小密钥相关的键值映射，或 `null`如果Map是空的。
`K`	`firstKey()` 返回当前在该Map中的第一个（最低）键。
`Map.Entry<K,V>`	`floorEntry(K key)` 返回的键值映射与最大的小于或等于给定的键，或 `null`如果没有这样的关键。
`K`	`floorKey(K key)` 返回最大关键小于或等于给定的键，或 `null`如果没有这样的关键。
`void`	`forEach(BiConsumer<? super K,? super V> action)` 在该映射中的每个条目执行给定的操作，直到所有的条目被处理或操作抛出异常。
`V`	`get(Object key)` 返回指定的键映射的值，或 `null`如果这个Map不包含的键映射。
`SortedMap<K,V>`	`headMap(K toKey)` 返回从这个Map的关键是严格小于 `toKey`部分。
`NavigableMap<K,V>`	`headMap(K toKey, boolean inclusive)` 返回从这个Map的关键是少部分（或相等，如果 `inclusive`是真的） `toKey`。
`Map.Entry<K,V>`	`higherEntry(K key)` 返回的键值映射与最关键严格大于给定的键，或 `null`如果没有这样的关键。
`K`	`higherKey(K key)` 返回最关键严格大于给定的键，或 `null`如果没有这样的关键。
`Set<K>`	`keySet()` 返回一个 `Set`查看键包含在这个Map。
`Map.Entry<K,V>`	`lastEntry()` 返回一个与该Map的最大密钥相关的键值映射，或 `null`如果Map是空的。
`K`	`lastKey()` 返回当前在该Map中的最后（最高）键。
`Map.Entry<K,V>`	`lowerEntry(K key)` 返回的键值映射与最大的关键严格小于给定的键，或 `null`如果没有这样的关键。
`K`	`lowerKey(K key)` 返回最大关键严格小于给定的键，或 `null`如果没有这样的关键。
`NavigableSet<K>`	`navigableKeySet()` 返回一个 `NavigableSet`查看键包含在这个Map。
`Map.Entry<K,V>`	`pollFirstEntry()` 删除并返回一个与该图的最小密钥相关的键值映射，或 `null`如果Map是空的。
`Map.Entry<K,V>`	`pollLastEntry()` 删除并返回一个与该Map的最大密钥相关的键值映射，或 `null`如果Map是空的。
`V`	`put(K key, V value)` 将指定的值与此映射中的指定键关联。
`void`	`putAll(Map<? extends K,? extends V> map)` 从指定的映射到该Map的所有映射。
`V`	`remove(Object key)` 除去这TreeMap这个关键的映射，如果存在。
`V`	`replace(K key, V value)` 仅当它当前映射到某一值时，替换指定的键的条目。
`boolean`	`replace(K key, V oldValue, V newValue)` 仅当当前映射到指定的值时，替换指定的键的条目。
`void`	`replaceAll(BiFunction<? super K,? super V,? extends V> function)` 将每个条目的值替换为在该项上调用给定函数的结果，直到所有的条目都被处理或函数抛出异常。
`int`	`size()` 返回这个映射中的键值映射的数目。
`NavigableMap<K,V>`	`subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)` 返回从这个Map的键范围从 `fromKey`到 `toKey`部分。
`SortedMap<K,V>`	`subMap(K fromKey, K toKey)` 返回从这个Map的键范围从 `fromKey`，包容的部分 `toKey`，独家。
`SortedMap<K,V>`	`tailMap(K fromKey)` 返回从这个Map的关键是大于或等于 `fromKey`部分。
`NavigableMap<K,V>`	`tailMap(K fromKey, boolean inclusive)` 返回从这个Map的关键是大于（或等于部分，如果 `inclusive`是真的） `fromKey`。
`Collection<V>`	`values()` 返回一个 `Collection`的价值观包含在这个Map。

Methods inherited from class java.util.AbstractMap
equals, hashCode, isEmpty, toString

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, equals, getOrDefault, hashCode, isEmpty, merge, putIfAbsent, remove

- Constructor Detail
  - TreeMap
```
public TreeMap()
```
    构造一个新的，空的树映射，使用它的键的自然顺序。所有的钥匙插入Map必须实现 Comparable接口。此外，所有钥匙必须相互比较： k1.compareTo(k2)不得把任何键 k1和 k2在Map ClassCastException。如果用户试图把钥匙插入Map违反此约束（例如，用户试图把一个字符串键进入Map的钥匙都是整数），该 put(Object key, Object value)称将 ClassCastException。
  - TreeMap
```
public TreeMap(Comparator<? super K> comparator)
```
    构造一个新的，空的树映射，根据给定的比较器排序。所有的钥匙插入Map必须由比较器被相互比较： comparator.compare(k1, k2)不得把任何键 k1和 k2在Map ClassCastException。如果用户试图把钥匙插入Map违反此约束的 put(Object key, Object value)称将 ClassCastException。
    
    参数
    
    comparator -比较器将用于订购这张Map。如果 null，钥匙的 natural ordering将使用。
  - TreeMap
```
public TreeMap(Map<? extends K,? extends V> m)
```
    构造了一个包含相同映射的新的树映射，根据它的键的自然顺序排列。所有的钥匙插入新的Map必须实现 Comparable接口。此外，所有钥匙必须相互比较： k1.compareTo(k2)不得把任何键 k1和 k2在Map ClassCastException。此方法在n *日志（n）时间内运行。
    
    参数
    
    m的映射被放置在这个Map的Map
    
    异常
    
    ClassCastException如果M键并不 Comparable，或互不可比
    
    NullPointerException -如果指定的Map是空的
  - TreeMap
```
public TreeMap(SortedMap<K,? extends V> m)
```
    构造一个包含相同映射的新树映射，并使用指定的排序映射使用相同的排序。该方法在线性时间内运行。
    
    参数
    
    m -排序图的映射是放在这张Map上，和其比较器是用来解决这个Map
    
    异常
    
    NullPointerException -如果指定的Map是空的
- 方法详细信息
  - size
```
public int size()
```
    返回这个映射中的键值映射的数目。
    
    Specified by:
    
    size 接口 Map<K,V>
    
    重写：
    
    size 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    在这个映射中的键值映射的数目
  - containsKey
```
public boolean containsKey(Object key)
```
    返回 true如果这Map包含一个指定的键映射。
    
    Specified by:
    
    containsKey 接口 Map<K,V>
    
    重写：
    
    containsKey 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key键的存在，在这张Map上可以进行测试
    
    结果
    
    true如果这Map包含一个指定的键映射
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
  - containsValue
```
public boolean containsValue(Object value)
```
    返回 true如果映射到指定的值的一个或多个键。更正式地说，返回 true当且仅当该Map包含至少一个映射到一个值 v这样 (value==null ? v==null : value.equals(v))。该操作可能需要的时间线在Map的大小对于大多数的实现。
    
    Specified by:
    
    containsValue 接口 Map<K,V>
    
    重写：
    
    containsValue 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    在这张Map上 value -它的存在价值进行测试
    
    结果
    
    true如果映射到 value存在； false否则
    
    从以下版本开始：
    
    一点二
  - get
```
public V get(Object key)
```
    返回指定的键映射的值，或 null如果这个Map不包含的键映射。
    更正式地说，如果这个图中包含了从关键k到价值v这样key比较等于k根据Map的排序，那么这个方法返回v；否则返回null。（最多只能有一个这样的映射。）
    
    一个null返回值并不一定表明，Map不包含的键映射；也有可能是Map明确地映射到null关键。的containsKey操作可用于区分这两例。
    
    Specified by:
    
    get 接口 Map<K,V>
    
    重写：
    
    get 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key -关键的相关值被返回
    
    结果
    
    值，指定的键映射，或 null如果这个Map不包含的键映射
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
  - comparator
```
public Comparator<? super K> comparator()
```
    从接口复制的描述： SortedMap
    
    返回用于秩序在这个Map钥匙的比较器，或 null如果这个Map使用其密钥的 natural ordering。
    
    Specified by:
    
    comparator 接口 SortedMap<K,V>
    
    结果
    
    比较器用以在这个Map的钥匙，或 null如果这个Map使用的键的自然顺序
  - firstKey
```
public K firstKey()
```
    从接口复制的描述： SortedMap
    
    返回当前在该Map中的第一个（最低）键。
    
    Specified by:
    
    firstKey 接口 SortedMap<K,V>
    
    结果
    
    在这个Map中的第一个（最低）键
    
    异常
    
    NoSuchElementException -如果这Map是空的
  - lastKey
```
public K lastKey()
```
    从接口复制的描述： SortedMap
    
    返回当前在该Map中的最后（最高）键。
    
    Specified by:
    
    lastKey 接口 SortedMap<K,V>
    
    结果
    
    在这个Map中的最后（最高）键
    
    异常
    
    NoSuchElementException -如果这Map是空的
  - putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
    从指定的映射到该Map的所有映射。这些映射替换此映射在指定Map中的任何键的任何映射。
    
    Specified by:
    
    putAll 接口 Map<K,V>
    
    重写：
    
    putAll 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    map映射被存储在这个Map
    
    异常
    
    ClassCastException -如果指定Map的键或值班防止它被存储在这个Map
    
    NullPointerException -如果指定的Map是空的或指定的Map包含一个空的钥匙和Map不允许null键
  - put
```
public V put(K key,
             V value)
```
    将指定的值与此映射中的指定键关联。如果映射以前包含一个键的映射，旧值将被替换。
    
    Specified by:
    
    put 接口 Map<K,V>
    
    重写：
    
    put 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key键与指定的值是相关联的
    
    value值必须与指定键关联
    
    结果
    
    与 key以前的值，或者 null如果没有映射的 key。（一 null返回也表明Map以前相关的 null与 key。）
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
  - remove
```
public V remove(Object key)
```
    除去这TreeMap这个关键的映射，如果存在。
    
    Specified by:
    
    remove 接口 Map<K,V>
    
    重写：
    
    remove 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key键的映射应该被删除
    
    结果
    
    与 key以前的值，或者 null如果没有映射的 key。（一 null返回也表明Map以前相关的 null与 key。）
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
  - clear
```
public void clear()
```
    从这个映射中移除所有的映射。这个调用返回后的Map将是空的。
    
    Specified by:
    
    clear 接口 Map<K,V>
    
    重写：
    
    clear 方法重写，继承类 AbstractMap<K,V>
  - clone
```
public Object clone()
```
    返回该 TreeMap实例浅拷贝。（键和值本身没有被克隆。）
    
    重写：
    
    clone 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    这张Map的浅本
    
    另请参见：
    
    Cloneable
  - firstEntry
```
public Map.Entry<K,V> firstEntry()
```
    从接口复制的描述： NavigableMap
    
    返回一个与该图的最小密钥相关的键值映射，或 null如果Map是空的。
    
    Specified by:
    
    firstEntry 接口 NavigableMap<K,V>
    
    结果
    
    一个用最少的按键输入，或 null如果这个Map是空的
    
    从以下版本开始：
    
    一点六
  - lastEntry
```
public Map.Entry<K,V> lastEntry()
```
    从接口复制的描述： NavigableMap
    
    返回一个与该Map的最大密钥相关的键值映射，或 null如果Map是空的。
    
    Specified by:
    
    lastEntry 接口 NavigableMap<K,V>
    
    结果
    
    一个最关键的条目，或 null如果这个Map是空的
    
    从以下版本开始：
    
    一点六
  - pollFirstEntry
```
public Map.Entry<K,V> pollFirstEntry()
```
    从接口复制的描述： NavigableMap
    
    删除并返回一个与该图的最小密钥相关的键值映射，或 null如果Map是空的。
    
    Specified by:
    
    pollFirstEntry 接口 NavigableMap<K,V>
    
    结果
    
    被删除的第一次进入这个Map，或 null如果这个Map是空的
    
    从以下版本开始：
    
    一点六
  - pollLastEntry
```
public Map.Entry<K,V> pollLastEntry()
```
    从接口复制的描述： NavigableMap
    
    删除并返回一个与该Map的最大密钥相关的键值映射，或 null如果Map是空的。
    
    Specified by:
    
    pollLastEntry 接口 NavigableMap<K,V>
    
    结果
    
    删除这个Map上的入口，或 null如果这个Map是空的
    
    从以下版本开始：
    
    一点六
  - lowerEntry
```
public Map.Entry<K,V> lowerEntry(K key)
```
    从接口复制的描述： NavigableMap
    
    返回的键值映射与最大的关键严格小于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    lowerEntry 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    一个最大的不足 key入境，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
    
    从以下版本开始：
    
    一点六
  - lowerKey
```
public K lowerKey(K key)
```
    从接口复制的描述： NavigableMap
    
    返回最大关键严格小于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    lowerKey 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    最大的不足 key，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
    
    从以下版本开始：
    
    一点六
  - floorEntry
```
public Map.Entry<K,V> floorEntry(K key)
```
    从接口复制的描述： NavigableMap
    
    返回的键值映射与最大的小于或等于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    floorEntry 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    一个最关键的小于或等于 key入境，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
    
    从以下版本开始：
    
    一点六
  - floorKey
```
public K floorKey(K key)
```
    从接口复制的描述： NavigableMap
    
    返回最大关键小于或等于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    floorKey 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    最关键的是小于或等于 key，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
    
    从以下版本开始：
    
    一点六
  - ceilingEntry
```
public Map.Entry<K,V> ceilingEntry(K key)
```
    从接口复制的描述： NavigableMap
    
    返回的键值映射与最关键的大于或等于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    ceilingEntry 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    一个大于或等于 key最关键的条目，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
    
    从以下版本开始：
    
    一点六
  - ceilingKey
```
public K ceilingKey(K key)
```
    从接口复制的描述： NavigableMap
    
    最关键的收益大于或等于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    ceilingKey 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    大于或等于 key最关键，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
    
    从以下版本开始：
    
    一点六
  - higherEntry
```
public Map.Entry<K,V> higherEntry(K key)
```
    从接口复制的描述： NavigableMap
    
    返回的键值映射与最关键严格大于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    higherEntry 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    一个大于 key最关键的条目，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
    
    从以下版本开始：
    
    一点六
  - higherKey
```
public K higherKey(K key)
```
    从接口复制的描述： NavigableMap
    
    返回最关键严格大于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    higherKey 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    大于 key最关键，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是无效的，这张Map使用自然排序，或者比较不允许null键
    
    从以下版本开始：
    
    一点六
  - keySet
```
public Set<K> keySet()
```
    返回一个 Set的关键视图包含在这个Map。
    该集合的迭代器以提升顺序返回键。设定的spliterator是后期绑定，快速失败，并报告Spliterator.SORTED和Spliterator.ORDERED与遇到的秩序，提升关键点。的spliterator的比较器（见Spliterator.getComparator()）是null如果树图的比较（见comparator()）是null。否则，该spliterator的比较器相同或施加相同的总排序为树图的比较。
    
    该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。如果Map是在设置一个迭代过程中修改（除非通过迭代器的remove操作），迭代的结果是不确定的。设置支持元素的去除，从Map中移除相应的映射，通过Iterator.remove，Set.remove，removeAll，retainAll，和clear操作。它不支持add或addAll操作。
    
    Specified by:
    
    keySet 接口 Map<K,V>
    
    Specified by:
    
    keySet 接口 SortedMap<K,V>
    
    重写：
    
    keySet 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    在这个Map中包含的键的一个集合视图
  - navigableKeySet
```
public NavigableSet<K> navigableKeySet()
```
    从接口复制的描述： NavigableMap
    
    返回一个 NavigableSet查看键包含在这个Map。该集合的迭代器以提升顺序返回键。该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。如果Map是在设置一个迭代过程中修改（除非通过迭代器的 remove操作），迭代的结果是不确定的。设置支持元素的去除，从Map中移除相应的映射，通过 Iterator.remove， Set.remove， removeAll， retainAll，和 clear操作。它不支持 add或 addAll操作。
    
    Specified by:
    
    navigableKeySet 接口 NavigableMap<K,V>
    
    结果
    
    在这张Map上的键的可导航的集合视图
    
    从以下版本开始：
    
    一点六
  - descendingKeySet
```
public NavigableSet<K> descendingKeySet()
```
    从接口复制的描述： NavigableMap
    
    返回一个相反的顺序 NavigableSet查看键包含在这个Map。该集合的迭代器以递减的顺序返回键。该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。如果Map是在设置一个迭代过程中修改（除非通过迭代器的 remove操作），迭代的结果是不确定的。设置支持元素的去除，从Map中移除相应的映射，通过 Iterator.remove， Set.remove， removeAll， retainAll，和 clear操作。它不支持 add或 addAll操作。
    
    Specified by:
    
    descendingKeySet 接口 NavigableMap<K,V>
    
    结果
    
    在这张Map中的键的一个反向顺序可导航的集合视图
    
    从以下版本开始：
    
    一点六
  - values
```
public Collection<V> values()
```
    返回一个 Collection视图的值包含在这个Map。
    集合的迭代器返回相应键的上升顺序的值。收集的spliterator是后期绑定，快速失败，并报告一遇到秩序，提升相应的按键顺序Spliterator.ORDERED。
    
    集合是由Map支持的，所以对Map的变化反映在集合中，反之亦然。如果Map是在集合的迭代进行修改（除非通过迭代器的remove操作），迭代的结果是不确定的。收集支持元素的去除，从Map中移除相应的映射，通过Iterator.remove，Collection.remove，removeAll，retainAll和clear操作。它不支持add或addAll操作。
    
    Specified by:
    
    values 接口 Map<K,V>
    
    Specified by:
    
    values 接口 SortedMap<K,V>
    
    重写：
    
    values 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    一个包含在这个Map中的值的集合视图
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    返回一个 Set映射的视图包含在这个Map。
    该集合的迭代器返回键顺序中的条目。本集的spliterator是后期绑定，快速失败，并报告Spliterator.SORTED和Spliterator.ORDERED与遇到的秩序，提升关键点。
    
    该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。如果Map是在设置一个迭代过程中修改（除非通过迭代器的remove操作，或通过setValue操作返回的迭代器的映射项）的迭代的结果是不确定的。设置支持元素的去除，从Map中移除相应的映射，通过Iterator.remove，Set.remove，removeAll，retainAll和clear操作。它不支持add或addAll操作。
    
    Specified by:
    
    entrySet 接口 Map<K,V>
    
    Specified by:
    
    entrySet 接口 SortedMap<K,V>
    
    Specified by:
    
    entrySet 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    映射中包含的映射的一个集合视图
  - descendingMap
```
public NavigableMap<K,V> descendingMap()
```
    从接口复制的描述： NavigableMap
    
    返回此映射中包含的映射的逆顺序视图。该Map是由这张Map的支持，所以对Map的变化反映在Map上，反之亦然。如果Map是在一个Map的集合视图的迭代过程中修改（除非通过迭代器的 remove操作），迭代的结果是不确定的。
    返回Map具有订购相当于Collections.reverseOrder(comparator())。表达m.descendingMap().descendingMap()返回从m本质上相当于m。
    
    Specified by:
    
    descendingMap 接口 NavigableMap<K,V>
    
    结果
    
    这张Map的一个相反的顺序视图
    
    从以下版本开始：
    
    一点六
  - subMap
```
public NavigableMap<K,V> subMap(K fromKey,
                                boolean fromInclusive,
                                K toKey,
                                boolean toInclusive)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的键范围从 fromKey到 toKey部分。如果 fromKey和 toKey相等，返回Map是空的，除非 fromInclusive toInclusive都是真实的。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在它的范围之外的一个IllegalArgumentException，或构建一个区块是其端点超出其范围。
    
    Specified by:
    
    subMap 接口 NavigableMap<K,V>
    
    参数
    
    fromKey -返回Map的关键端点低
    
    fromInclusive - true如果低的终点是被包含在返回的视图
    
    toKey -返回Map的关键点
    
    toInclusive - true如果高终点是被包含在返回的视图
    
    结果
    
    看这张Map的键范围从 fromKey到 toKey部分
    
    异常
    
    ClassCastException -如果 fromKey和 toKey不能与另一个使用这个Map的比较器（或者，如果Map没有比较器，采用自然排序）。实现可能，但不是必需的，如果 fromKey或 toKey不能相比，目前在Map键抛出该异常。
    
    NullPointerException -如果 fromKey或 toKey是无效的，这张Map使用自然排序，或者比较不允许null键
    
    IllegalArgumentException -如果 fromKey大于 toKey；或者如果这Map本身有一个限制的范围内，和 fromKey或 toKey超出范围的界限
    
    从以下版本开始：
    
    一点六
  - headMap
```
public NavigableMap<K,V> headMap(K toKey,
                                 boolean inclusive)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的关键是少部分（或相等，如果 inclusive是真的） toKey。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的IllegalArgumentException。
    
    Specified by:
    
    headMap 接口 NavigableMap<K,V>
    
    参数
    
    toKey -返回Map的关键点
    
    inclusive - true如果高终点是被包含在返回的视图
    
    结果
    
    看这张Map的关键是少部分（或相等，如果 inclusive是真的） toKey
    
    异常
    
    ClassCastException -如果 toKey不是这个Map的比较器兼容的（或者，如果Map没有比较，如果 toKey不实现 Comparable）。实现可能，但不是必需的，如果 toKey不能相比，目前在Map键抛出该异常。
    
    如果 toKey NullPointerException是无效的，这张Map使用自然排序，或者比较不允许null键
    
    IllegalArgumentException -如果这Map本身有一个限制的范围内，和 toKey超出范围的界限
    
    从以下版本开始：
    
    一点六
  - tailMap
```
public NavigableMap<K,V> tailMap(K fromKey,
                                 boolean inclusive)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的关键是大于（或等于部分，如果 inclusive是真的） fromKey。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的IllegalArgumentException。
    
    Specified by:
    
    tailMap 接口 NavigableMap<K,V>
    
    参数
    
    fromKey -返回Map的关键端点低
    
    inclusive - true如果低的终点是被包含在返回的视图
    
    结果
    
    看这张Map的关键是大于（或等于部分，如果 inclusive是真的） fromKey
    
    异常
    
    ClassCastException -如果 fromKey不是这个Map的比较器兼容的（或者，如果Map没有比较，如果 fromKey不实现 Comparable）。实现可能，但不是必需的，如果 fromKey不能相比，目前在Map键抛出该异常。
    
    如果 fromKey NullPointerException是无效的，这张Map使用自然排序，或者比较不允许null键
    
    IllegalArgumentException -如果这Map本身有一个限制的范围内，和 fromKey超出范围的界限
    
    从以下版本开始：
    
    一点六
  - subMap
```
public SortedMap<K,V> subMap(K fromKey,
                             K toKey)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的键范围从 fromKey，包容的部分 toKey，独家。（如果 fromKey和 toKey相等，返回Map是空的。）返回的Map由Map的支持，所以在返回的Map变化都反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的IllegalArgumentException。
    
    相当于subMap(fromKey, true, toKey, false)。
    
    Specified by:
    
    subMap 接口 NavigableMap<K,V>
    
    Specified by:
    
    subMap 接口 SortedMap<K,V>
    
    参数
    
    fromKey低端点（含）返回的映射中的键
    
    toKey高端点（独家）返回的映射中的键
    
    结果
    
    看这张Map的键范围从 fromKey，包容的部分 toKey，独家
    
    异常
    
    ClassCastException -如果 fromKey和 toKey不能与另一个使用这个Map的比较器（或者，如果Map没有比较器，采用自然排序）。实现可能，但不是必需的，如果 fromKey或 toKey不能相比，目前在Map键抛出该异常。
    
    NullPointerException -如果 fromKey或 toKey是无效的，这张Map使用自然排序，或者比较不允许null键
    
    IllegalArgumentException -如果 fromKey大于 toKey；或者如果这Map本身有一个限制的范围内，和 fromKey或 toKey超出范围的界限
  - headMap
```
public SortedMap<K,V> headMap(K toKey)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的关键是严格小于 toKey部分。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的IllegalArgumentException。
    
    相当于headMap(toKey, false)。
    
    Specified by:
    
    headMap 接口 NavigableMap<K,V>
    
    Specified by:
    
    headMap 接口 SortedMap<K,V>
    
    参数
    
    toKey高端点（独家）返回的映射中的键
    
    结果
    
    看这张Map的关键是严格小于 toKey部分
    
    异常
    
    ClassCastException -如果 toKey不是这个Map的比较器兼容的（或者，如果Map没有比较，如果 toKey不实现 Comparable）。实现可能，但不是必需的，如果 toKey不能相比，目前在Map键抛出该异常。
    
    如果 toKey NullPointerException是无效的，这张Map使用自然排序，或者比较不允许null键
    
    IllegalArgumentException -如果这Map本身有一个限制的范围内，和 toKey超出范围的界限
  - tailMap
```
public SortedMap<K,V> tailMap(K fromKey)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的关键是大于或等于 fromKey部分。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的IllegalArgumentException。
    
    相当于tailMap(fromKey, true)。
    
    Specified by:
    
    tailMap 接口 NavigableMap<K,V>
    
    Specified by:
    
    tailMap 接口 SortedMap<K,V>
    
    参数
    
    fromKey低端点（含）返回的映射中的键
    
    结果
    
    看这张Map的关键是大于或等于 fromKey部分
    
    异常
    
    ClassCastException -如果 fromKey不是这个Map的比较器兼容的（或者，如果Map没有比较，如果 fromKey不实现 Comparable）。实现可能，但不是必需的，如果 fromKey不能相比，目前在Map键抛出该异常。
    
    如果 fromKey NullPointerException是无效的，这张Map使用自然排序，或者比较不允许null键
    
    IllegalArgumentException -如果这Map本身有一个限制的范围内，和 fromKey超出范围的界限
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    从接口复制的描述： Map
    
    仅当当前映射到指定的值时，替换指定的键的条目。
    
    Specified by:
    
    replace 接口 Map<K,V>
    
    参数
    
    key键与指定值相关联的
    
    oldValue值将与指定键关联
    
    newValue值必须与指定键关联
    
    结果
    
    true如果值代替
  - replace
```
public V replace(K key,
                 V value)
```
    从接口复制的描述： Map
    
    仅当它当前映射到某一值时，替换指定的键的条目。
    
    Specified by:
    
    replace 接口 Map<K,V>
    
    参数
    
    key键与指定值相关联的
    
    value值必须与指定键关联
    
    结果
    
    与指定的键相关联的前一个值，或 null如果没有键映射。（一 null返回也表明，与先前的 nullMap的关键，如果实施支持空值。）
  - forEach
```
public void forEach(BiConsumer<? super K,? super V> action)
```
    从接口复制的描述： Map
    
    在该映射中的每个条目执行给定的操作，直到所有的条目被处理或操作抛出异常。除非实现类的其他指定，否则操作在输入集迭代的顺序（如果指定的迭代顺序）中执行。由操作引发的异常被传递给调用方。
    
    Specified by:
    
    forEach 接口 Map<K,V>
    
    参数
    
    action将每项执行的动作
  - replaceAll
```
public void replaceAll(BiFunction<? super K,? super V,? extends V> function)
```
    从接口复制的描述： Map
    
    将每个条目的值替换为在该项上调用给定函数的结果，直到所有的条目都被处理或函数抛出异常。由函数抛出的异常被传递给调用方。
    
    Specified by:
    
    replaceAll 接口 Map<K,V>
    
    参数
    
    function -功能适用于每一个条目

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class TreeMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap

构造方法摘要

方法摘要

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Constructor Detail

TreeMap

TreeMap

TreeMap

TreeMap

方法详细信息

size

containsKey

containsValue

get

comparator

firstKey

lastKey

putAll

put

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

replace

replace

forEach

replaceAll