TreeMap<K,V>类

时间：2020-03-07 14:25:19 阅读：89 评论：0 收藏：0 [点我收藏+]

所在包：java.util.TreeMap

技术分享图片

类型参数：

　　K —— 此映射维护的键的类型

　　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实现。

该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。

此实现为 containsKey、get、put 和 remove 操作提供受保证的 log(n) 时间开销。这些算法是 Cormen、Leiserson 和 Rivest 的 Introduction to Algorithms 中的算法的改编。

注意，如果要正确实现 Map 接口，则有序映射所保持的顺序（无论是否明确提供了比较器）都必须与 equals 一致。（关于与 equals 一致 的精确定义，请参阅 Comparable 或 Comparator）。这是因为 Map 接口是按照 equals 操作定义的，但有序映射使用它的 compareTo（或 compare）方法对所有键进行比较，因此从有序映射的观点来看，此方法认为相等的两个键就是相等的。即使排序与 equals 不一致，有序映射的行为仍然是定义良好的，只不过没有遵守 Map 接口的常规协定。

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

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

collection（由此类所有的“collection 视图方法”返回）的 iterator 方法返回的迭代器都是快速失败 的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器自身的 remove 方法，否则在其他任何时间以任何方式进行修改都将导致迭代器抛出 ConcurrentModificationException。因此，对于并发的修改，迭代器很快就完全失败，而不会冒着在将来不确定的时间发生不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证，一般来说，当存在不同步的并发修改时，不可能作出任何肯定的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。

此类及其视图中的方法返回的所有 Map.Entry 对都表示生成它们时的映射关系的快照。它们不支持 Entry.setValue 方法。（不过要注意的是，使用 put 更改相关映射中的映射关系是有可能的。）

此类是 Java Collections Framework 的成员。

从以下版本开始：: 1.2
另请参见：: Map, HashMap, Hashtable, Comparable, Comparator, Collection,Serialized Form

Nested Class Summary

嵌套类摘要

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

嵌套类/接口继承自 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`键，如果没有此键，则返回 `null` 。
`void`	`clear()` 从这张映射中删除所有的映射。
`Object`	`clone()` 返回此 `TreeMap`实例的浅拷贝。
`Comparator<? super K>`	`comparator()` 返回用于订购此映射中的键的比较器，或`null`如果此映射使用其键的natural ordering 。
`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` 。
`void`	`forEach(BiConsumer<? super K,? super V> action)` 对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
`V`	`get(Object key)` 返回到指定键所映射的值，或 `null`如果此映射包含该键的映射。
`SortedMap<K,V>`	`headMap(K toKey)` 返回此映射部分的视图，其密钥严格小于 `toKey` 。
`NavigableMap<K,V>`	`headMap(K toKey, boolean inclusive)` 返回此映射部分的视图，其键值小于（或等于，如果 `inclusive`为真） `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` 。
`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`	`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)` 返回此映射部分的视图，其关键范围为 `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`为真） `fromKey` 。
`Collection<V>`	`values()` 返回此映射中包含的值的`Collection`视图。

Methods inherited from class java.util.AbstractMap

以下方法继承自java.util.AbstractMap类

equals, hashCode, isEmpty, toString

Methods inherited from class java.lang.Object

以下方法继承自java.lang.Object类

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Map

以下方法继承自java.util.Map接口

compute, computeIfAbsent, computeIfPresent, equals, getOrDefault, hashCode, isEmpty, merge, putIfAbsent, remove

构造方法详细信息

TreeMap
```
public TreeMap()
```
使用其键的自然排序构造一个新的空树状图。插入映射的所有键都必须实现Comparable界面。此外，所有这些密钥必须是相互可比的 ： k1.compareTo(k2)不能为ClassCastException中的任何键k1和k2 。如果用户试图将一个键放入违反该约束的映射中（例如，用户尝试将一个字符串键放入一个键为整数的映射中），则put(Object key, Object value)调用将抛出ClassCastException 。

TreeMap
```
public TreeMap(Comparator<? super K> comparator)
```
构造一个新的，空的树图，按照给定的比较器排序。插入到映射中的所有键必须由给定的比较器相互比较 ： comparator.compare(k1, k2)不得为ClassCastException中的任何键k1和k2 。如果用户试图将一个键放入映射中，违反此约束，则put(Object key, Object value)调用将抛出ClassCastException 。

参数
comparator - 将用于订购此映射的比较器。如果null ，则使用natural ordering的按键。

TreeMap
```
public TreeMap(Map<? extends K,? extends V> m)
```
构造一个新的树状图，其中包含与给定映射相同的映射，根据其键的自然顺序进行排序 。插入新映射的所有键必须实现Comparable界面。此外，所有这些密钥必须是相互可比的 ： k1.compareTo(k2)不能为ClassCastException中的任何键k1和k2 。此方法运行在n * log（n）时间。

参数
m - 其映射将放置在此映射中的映射
异常
ClassCastException - 如果m中的键不是Comparable ，或者不相互比较
NullPointerException - 如果指定的映射为空

- TreeMap
```
public TreeMap(SortedMap<K,? extends V> m)
```
  构造一个包含相同映射并使用与指定排序映射相同顺序的新树映射。该方法运行在线性时间。
  
  参数
  m - 其映射将被放置在该映射中的排序映射，并且其比较器将用于对该映射进行排序
  异常
  NullPointerException - 如果指定的映射为空

方法详细信息

size
```
public int size()
```
返回此映射中键值映射的数量。

Specified by:
size在界面 Map<K,V>
重写：
size在 AbstractMap<K,V>
结果
该映射中键值映射的数量

containsKey
```
public boolean containsKey(Object key)
```
如果此映射包含指定键的映射，则返回 true 。

Specified by:
containsKey在界面 Map<K,V>
重写：
containsKey在类别 AbstractMap<K,V>
参数
key - 要在此映射中存在的密钥要进行测试
结果
true如果此映射包含指定键的映射
异常
ClassCastException - 如果指定的键不能与当前在映射中的键进行比较
NullPointerException - 如果指定的键为空，并且此映射使用自然排序，或者其比较器不允许空键

containsValue
```
public boolean containsValue(Object value)
```
如果此映射将一个或多个键映射到指定的值，则返回true 。更正式地，返回true如果且仅当此映射包含至少一个映射到值v ，使得(value==null ? v==null : value.equals(v)) 。对于大多数实现，此操作可能需要在映射大小的时间线性。

Specified by:
containsValue在界面 Map<K,V>
重写：
containsValue在类别 AbstractMap<K,V>
参数
value - 要在此映射中存在的值要进行测试
结果
true如果映射到value存在; false否则
从以下版本开始：
1.2

get
```
public V get(Object key)
```
返回到指定键所映射的值，或null如果此映射包含该键的映射。
更正式地，如果该映射包含从键k到值v ，使得key根据映射的排序等于k ，则该方法返回v ; 否则返回null 。（最多可以有一个这样的映射。）

返回值null并不一定表示该映射不包含该键的映射; 映射也可能明确地将密钥映射到null 。可以使用containsKey操作来区分这两种情况。

Specified by:
get在界面 Map<K,V>
重写：
get在 AbstractMap<K,V>
参数
key - 要返回其关联值的键
结果
指定键映射到的值，如果此映射不包含键的映射， null
异常
ClassCastException - 如果指定的键不能与当前在映射中的键进行比较
NullPointerException - 如果指定的键为空，并且该映射使用自然排序，或者其比较器不允许空键

comparator
```
public Comparator<? super K> comparator()
```
说明从界面： SortedMap复制

返回用于订购此映射中的键的比较器，或null如果此映射使用其键的natural ordering 。

Specified by:
comparator在界面 SortedMap<K,V>
结果
比较器用于订购此映射中的键，或 null如果该映射使用其键的自然排序

firstKey
```
public K firstKey()
```
说明从界面： SortedMap复制

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

Specified by:
firstKey在界面 SortedMap<K,V>
结果
当前在此映射中的第一（最低）键
异常
NoSuchElementException - 如果 NoSuchElementException空

lastKey
```
public K lastKey()
```
说明从界面： SortedMap复制

返回当前在此映射中的最后（最高）键。

Specified by:
lastKey在界面 SortedMap<K,V>
结果
当前在此映射中的最后（最高）键
异常
NoSuchElementException - 如果这张映射是空的

putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
将指定映射的所有映射复制到此映射。这些映射取代了此映射对当前指定映射中的任何键的任何映射。

Specified by:
putAll在界面 Map<K,V>
重写：
putAll在类别 AbstractMap<K,V>
参数
map - 要存储在此映射中的映射
异常
ClassCastException - 如果指定映射中的键或值的类别阻止其存储在此映射中
NullPointerException - 如果指定的映射为空或指定的映射包含空键，并且此映射不允许空键

put
```
public V put(K key,
             V value)
```
将指定的值与此映射中的指定键相关联。如果映射先前包含了该键的映射，则替换旧值。

Specified by:
put在界面 Map<K,V>
重写：
put在类别 AbstractMap<K,V>
参数
key - 指定值与之关联的键
value - 与指定键相关联的值
结果
前一个值与key ，或null如果没有key映射。（A null返回也可以指示以前关联的映射null与key ）
异常
ClassCastException - 如果指定的键不能与当前在映射中的键进行比较
NullPointerException - 如果指定的键为空，此映射使用自然排序，或者其比较器不允许空键

remove
```
public V remove(Object key)
```
从此TreeMap中删除此键的映射（如果存在）。

Specified by:
remove在界面 Map<K,V>
重写：
remove在类别 AbstractMap<K,V>
参数
key - 应该删除哪个映射的键
结果
前一个值与key ，或null如果没有key映射。（A null返回也可以表示该映射之前关联的null与key ）
异常
ClassCastException - 如果指定的键不能与当前在映射中的键进行比较
NullPointerException - 如果指定的键为空，并且该映射使用自然排序，或者其比较器不允许空值

clear
```
public void clear()
```
从这张映射中删除所有的映射。此调用返回后，映射将为空。

Specified by:
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 。

Specified by:
接口 NavigableMap<K,V> 中的 firstEntry
结果
带有最小键的条目；如果此映射为空，则返回 null
从以下版本开始：
1.6

lastEntry
```
public Map.Entry<K,V> lastEntry()
```
从接口 NavigableMap 复制的描述

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

Specified by:
接口 NavigableMap<K,V> 中的 lastEntry
结果
带有最大键的条目；如果此映射为空，则返回 null
从以下版本开始：
1.6

pollFirstEntry
```
public Map.Entry<K,V> pollFirstEntry()
```
从接口 NavigableMap 复制的描述

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

Specified by:
接口 NavigableMap<K,V> 中的 pollFirstEntry
结果
此映射中被移除的第一个条目；如果此映射为空，则返回 nulll
从以下版本开始：
1.6

pollLastEntry
```
public Map.Entry<K,V> pollLastEntry()
```
从接口 NavigableMap 复制的描述

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

Specified by:
接口 NavigableMap<K,V> 中的 pollLastEntry
结果
此映射中被移除的最后一个条目；如果此映射为空，则返回 null
从以下版本开始：
1.6

lowerEntry
```
public Map.Entry<K,V> lowerEntry(K key)
```
从接口 NavigableMap 复制的描述

返回一个键-值映射关系，它与严格小于给定键的最大键关联；如果不存在这样的键，则返回 null

Specified by:
接口 NavigableMap<K,V> 中的 lowerEntry
参数
key - 键
结果
最大键小于 key 的条目；如果不存在这样的键，则返回 null
异常
ClassCastException - 如果指定键不能与映射中的当前键进行比较
NullPointerException - 如果指定键为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
从以下版本开始：
1.6

lowerKey
```
public K lowerKey(K key)
```
从接口 NavigableMap 复制的描述

返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。

Specified by:
接口 NavigableMap<K,V> 中的 lowerKey
参数
key - 键
结果
返回小于 key 的最大键；如果不存在这样的键，则返回 null
异常
ClassCastException - 如果指定键不能与映射中的当前键进行比较
NullPointerException - 如果指定键为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
从以下版本开始：
1.6

floorEntry
```
public Map.Entry<K,V> floorEntry(K key)
```
从接口 NavigableMap 复制的描述

返回一个键-值映射关系，它与小于等于给定键的最大键关联；如果不存在这样的键，则返回 null。

Specified by:
接口 NavigableMap<K,V> 中的 floorEntry
参数
key - 键
结果
返回最大键小于等于 key 的条目；如果不存在这样的键，则返回 null
异常
ClassCastException - 如果指定键不能与映射中的当前键进行比较。
NullPointerException - 如果指定键为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键。
从以下版本开始：
1.6

floorKey
```
public K floorKey(K key)
```
从接口 NavigableMap 复制的描述

返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。
Specified by:
接口 NavigableMap<K,V> 中的 floorKey
参数
key - 键
结果
返回小于等于 key 的最大键；如果不存在这样的键，则返回 null
异常
ClassCastException - 如果指定键不能与映射中的当前键进行比较。
NullPointerException - 如果指定键为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键。
从以下版本开始：
1.6

ceilingEntry
```
public Map.Entry<K,V> ceilingEntry(K key)
```
从接口 NavigableMap 复制的描述

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

Specified by:
接口 NavigableMap<K,V> 中的 ceilingEntry
参数
key - 键
结果
返回最小键大于等于 key 的条目；如果不存在这样的键，则返回 null
异常
ClassCastException - 如果指定键不能与映射中的当前键进行比较
NullPointerException - 如果指定键为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
从以下版本开始：
1.6

ceilingKey
```
public K ceilingKey(K key)
```
从接口 NavigableMap 复制的描述

返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。

Specified by:
接口 NavigableMap<K,V> 中的 ceilingKey
参数
key - 键
结果
返回接口 NavigableMap<K,V> 中的 ceilingKey
异常
ClassCastException - 如果指定键不能与映射中的当前键进行比较
NullPointerException - 如果指定键为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
从以下版本开始：
1.6

higherEntry
```
public Map.Entry<K,V> higherEntry(K key)
```
从接口 NavigableMap 复制的描述

返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。

Specified by:
返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。
参数
key - 键
结果
返回最小键大于 key 的条目；如果不存在这样的键，则返回 null
异常
ClassCastException - 如果指定键不能与映射中的当前键进行比较
NullPointerException - 如果指定键为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
从以下版本开始：
1.6

higherKey
```
public K higherKey(K key)
```
从接口 NavigableMap 复制的描述

返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。

Specified by:
接口 NavigableMap<K,V> 中的 higherKey
参数
key - 键
结果
返回大于 key 的最小键；如果不存在这样的键，则返回 null
异常
ClassCastException - 如果指定键不能与映射中的当前键进行比较
NullPointerException - 如果指定键为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
从以下版本开始：
1.6

keySet
```
public Set<K> keySet()
```
返回此映射包含的键的 Set 视图。
set 的迭代器将按升序返回这些键。该 set 受映射支持，所以对映射的更改可在此 set 中反映出来，反之亦然。如果对该 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。此 set 支持元素移除，通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作，可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

Specified by:
接口 Map<K,V> 中的 keySet
Specified by:
接口 SortedMap<K,V> 中的 keySet
重写：
类 AbstractMap<K,V> 中的 keySet
结果
此映射中包含的键的 set 视图

navigableKeySet
```
public NavigableSet<K> navigableKeySet()
```
从接口 NavigableMap 复制的描述

返回此映射中所包含键的 NavigableSet 视图。set 的迭代器按升序返回键。set 受映射支持，因此对映射的更改将反映在 set 中，反之亦然。如果正在对 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。set 支持元素移除，即通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

Specified by:
接口 NavigableMap<K,V> 中的 navigableKeySet
结果
此映射中键的可导航 set 视图
从以下版本开始：
1.6

descendingKeySet
```
public NavigableSet<K> descendingKeySet()
```
从接口 NavigableMap 复制的描述

返回此映射中所包含键的逆序 NavigableSet 视图。set 的迭代器按降序返回键。set 受映射支持，因此对映射的更改将反映在 set 中，反之亦然。如果正在对 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。set 支持元素移除，即通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

Specified by:
接口 NavigableMap<K,V> 中的 descendingKeySet
结果
接口 NavigableMap<K,V> 中的 descendingKeySet
从以下版本开始：
1.6

values
```
public Collection<V> values()
```
返回此映射包含的值的 Collection 视图。该 collection 的迭代器将按相关键的升序返回这些值。该 collection 受映射支持，所以对映射的更改可在此 collection 中反映出来，反之亦然。如果对该 collection 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外），则迭代结果是不确定的。该 collection 支持元素的移除，通过 Iterator.remove、Collection.remove、removeAll、retainAll 和 clear 操作，可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

Specified by:
接口 Map<K,V> 中的 values
Specified by:
接口 SortedMap<K,V> 中的 values
重写：
类 AbstractMap<K,V> 中的 values
结果
此映射中包含的值的 collection 视图

entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
返回此映射中包含的映射关系的 Set 视图。

该 set 的迭代器将按升序返回这些条目。该 set 受映射支持，所以对映射的更改可在此 set 中反映出来，反之亦然。如果对该 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作，或者通过在迭代器返回的映射条目上执行 setValue 操作除外），则迭代结果是不确定的。此 set 支持元素移除，通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作，可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

Specified by:
接口 Map<K,V> 中的 entrySet
Specified by:
接口 Map<K,V> 中的 entrySet
Specified by:
类 AbstractMap<K,V> 中的 entrySet
结果
　　此映射中包含的映射关系的 set 视图

descendingMap
```
public NavigableMap<K,V> descendingMap()
```
从接口 NavigableMap 复制的描述

返回此映射中包含的映射的反向排序视图。降序映射由该映射支持，所以对映射的更改反映在降序映射中，反之亦然。如果在映射的集合视图上的迭代正在进行（除了迭代器自己的remove之外），否则修改了任一映射，则迭代的结果是未定义的。
返回的映射的订单等价于Collections.reverseOrder(comparator()) 。表达式m.descendingMap().descendingMap()返回m.descendingMap().descendingMap()的视图， m相当于m 。

Specified by:
接口 NavigableMap<K,V> 中的 descendingMap
结果
此映射的逆序视图
从以下版本开始：
1.6

subMap
```
public NavigableMap<K,V> subMap(K fromKey,
                                boolean fromInclusive,
                                K toKey,
                                boolean toInclusive)
```
从接口 NavigableMap 复制的描述

返回此映射的部分视图，其键的范围从 fromKey 到 toKey。如果 fromKey 和 toKey 相等，则返回的映射为空，除非 fromExclusive 和 toExclusive 都为 true。返回的映射受此映射支持，因此返回映射中的更改将反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。

如果试图在返回映射的范围之外插入一个键，或者构造一个任一端点位于其范围之外的子映射，则返回的映射将抛出 IllegalArgumentException。

Specified by:
接口 NavigableMap<K,V> 中的 subMap
参数
ffromKey - 返回映射中键的低端点
fromInclusive - 如果低端点要包含在返回的视图中，则为 true
toKey - 返回映射中键的高端点
toInclusive - 如果高端点要包含在返回的视图中，则为 true
结果
此映射的部分视图，其键范围从 fromKey 到 toKey
异常
ClassCastException - 如果不能使用此映射的比较器（如果映射没有比较器，则使用自然顺序）比较
fromKey 和 toKey。如果 fromKey 或 toKey 不能与映射中当前键进行比较，则实现可以（但不是必须）抛出此异常。
NullPointerException - 如果 fromKey 或 toKey 为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
IllegalArgumentException - 如果 fromKey 大于 toKey；如果此映射本身有范围限制，并且 fromKey 或 toKey 位于范围的边界之外
从以下版本开始：
1.6

headMap
```
public NavigableMap<K,V> headMap(K toKey,
                                 boolean inclusive)
```
从接口 NavigableMap 复制的描述

返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。返回的映射受此映射支持，因此返回映射中的更改将反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。

如果试图在返回映射的范围之外插入一个键，则返回的映射将抛出 IllegalArgumentException。

Specified by:
接口 NavigableMap<K,V> 中的 headMap
参数
toKey - 返回映射中键的高端点
inclusive - 返回映射中键的高端点
结果
返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey
异常
ClassCastException - 如果 toKey 与此映射的比较器不兼容（如果映射没有比较器；如果 toKey 没有实现 Comparable）。如果 toKey 不能与映射中的当前键进行比较，则实现可以（但不是必须）抛出此异常。
NullPointerException - 如果 toKey 为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
IllegalArgumentException - 如果 toKey 为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
从以下版本开始：
1.6

tailMap
```
public NavigableMap<K,V> tailMap(K fromKey,
                                 boolean inclusive)
```
从接口 NavigableMap 复制的描述

返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。返回的映射受此映射支持，因此返回映射中的更改将反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。

如果试图在返回映射的范围之外插入一个键，则返回的映射将抛出 IllegalArgumentException。

Specified by:
接口 NavigableMap<K,V> 中的 tailMap
参数
fromKey - 接口 NavigableMap<K,V> 中的 tailMap
inclusive - 如果低端点要包含在返回的视图中，则为 true
结果
该地图的部分的视图，其键大于（或等于，如果 inclusive为真） fromKey
异常
ClassCastException - 如果 fromKey 与此映射的比较器不兼容（如果映射没有比较器；如果 fromKey 没有实现 Comparable）。如果 fromKey 不能与映射中的当前键进行比较，则实现可以（但不是必须）抛出此异常。
NullPointerException - 如果 fromKey 为 null，并且此映射使用自然顺序，或者其比较器不允许使用 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) 。

Specified by:
接口 NavigableMap<K,V> 中的 subMap
Specified by:
接口 SortedMap<K,V> 中的 subMap
参数
fromKey - 返回映射中键的低端点（包括）
toKey - 返回映射中键的高端点（不包括）
结果
此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）
异常
ClassCastException - 如果无法使用此映射的比较器（如果此映射没有比较器，则使用自然顺序）比较 fromKey 和 toKey。如果 fromKey 或 toKey 不能与映射中当前键进行比较，则实现可以（但不是必须）抛出此异常。
NullPointerException - 如果 fromKey 或 toKey 为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
IllegalArgumentException - 如果 fromKey 大于 toKey；如果此映射本身有范围限制，并且 fromKey 或 toKey 位于范围的边界之外

headMap
```
public SortedMap<K,V> headMap(K toKey)
```
从接口 NavigableMap 复制的描述

返回此映射的部分视图，其键值严格小于 toKey。返回的映射受此映射支持，所以在返回映射中的更改将反映在映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。

如果试图在返回映射的范围之外插入键，则返回的映射将抛出 IllegalArgumentException。

相当于headMap(toKey, false) 。

Specified by:
接口 NavigableMap<K,V> 中的 headMap
Specified by:
接口 SortedMap<K,V> 中的 headMap
参数
toKey - 返回映射中键的高端点（不包括）
结果
此映射的部分视图，该映射的键严格小于 toKey
异常
ClassCastException - 如果 toKey 与此映射的比较器不兼容（如果该映射没有比较器；如果 toKey 没有实现 Comparable）。如果 toKey 不能与映射中的当前键进行比较，则实现可以（但不是必须）抛出此异常。
NullPointerException - 如果 toKey 为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
IllegalArgumentException - 如果此映射本身有范围限制，并且 toKey 位于范围的边界之外

tailMap
```
public SortedMap<K,V> tailMap(K fromKey)
```
从接口 NavigableMap 复制的描述

返回此映射的部分视图，其键大于等于 fromKey。返回的映射受此映射支持，所以在返回映射中的更改将反映在映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。

如果试图在返回映射的范围之外插入键，则返回的映射将抛出 IllegalArgumentException。

相当于tailMap(fromKey, true) 。

Specified by:
接口 NavigableMap<K,V> 中的 tailMap
Specified by:
接口 SortedMap<K,V> 中的 tailMap
参数
fromKey - 返回映射中键的低端点（包括）
结果
此映射的部分视图，其键大于等于 fromKey
异常
ClassCastException - 如果 fromKey 与此映射的比较器不兼容（如果该映射没有比较器；如果 fromKey 没有实现 Comparable）。如果 fromKey 不能与映射中的当前键进行比较，则实现可以（但不　　是必须）抛出此异常。
NullPointerException - 如果 fromKey 为 null，并且此映射使用自然顺序，或者其比较器不允许使用 null 键
IllegalArgumentException - 如果此映射本身有范围限制，并且 fromKey 位于范围的边界之外

replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
从接口 NavigableMap 复制的描述

仅当当前映射到指定的值时，才能替换指定键的条目。

Specified by:
replace在接口 Map<K,V>
参数
key - 与指定值相关联的键
oldValue - 预期与指定键相关联的值
newValue - 与指定键相关联的值
结果
true如果该值被替换

replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
从接口 NavigableMap 复制的描述

仅当当前映射到指定的值时，才能替换指定键的条目。

Specified by:
replace在接口 Map<K,V>
参数
key - 与指定值相关联的键
oldValue - 预期与指定键相关联的值
newValue - 与指定键相关联的值
结果
true如果该值被替换

forEach
```
public void forEach(BiConsumer<? super K,? super V> action)
```
从接口 NavigableMap 复制的描述

对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。除非实现类另有指定，否则按照进入设置迭代的顺序执行操作（如果指定了迭代顺序）。操作引发的异常被转发给调用者。

Specified by:
forEach在界面 Map<K,V>
参数
action - 为每个条目执行的操作

replaceAll
```
public void replaceAll(BiFunction<? super K,? super V,? extends V> function)
```
从接口 NavigableMap 复制的描述

将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。函数抛出的异常被转发给调用者。

Specified by:
replaceAll在界面 Map<K,V>
参数
function - 应用于每个条目的功能

TreeMap<K,V>类

原文：https://www.cnblogs.com/LinQingYang/p/12433767.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)

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

构造方法详细信息

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