java.util.concurrent
类 ConcurrentSkipListMap<K,V>

java.lang.Object
  java.util.AbstractMap<K,V>
      java.util.concurrent.ConcurrentSkipListMap<K,V>

类型参数：

K - 此映射维护的键类型

V - 映射值的类型

所有已实现的接口：

Serializable, Cloneable, ConcurrentMap<K,V>, ConcurrentNavigableMap<K,V>, Map<K,V>, NavigableMap<K,V>, SortedMap<K,V>

public class ConcurrentSkipListMap<K,V>
extends AbstractMap<K,V>
implements ConcurrentNavigableMap<K,V>, Cloneable, Serializable

可缩放的并发 ConcurrentNavigableMap 实现。映射可以根据键的自然顺序进行排序，也可以根据创建映射时所提供的 Comparator 进行排序，具体取决于使用的构造方法。

此类实现 SkipLists 的并发变体，为 containsKey、get、put、remove 操作及其变体提供预期平均 log(n) 时间开销。多个线程可以安全地并发执行插入、移除、更新和访问操作。迭代器是弱一致 的，返回的元素将反映迭代器创建时或创建后某一时刻的映射状态。它们不 抛出 ConcurrentModificationException，可以并发处理其他操作。升序键排序视图及其迭代器比降序键排序视图及其迭代器更快。

此类及此类视图中的方法返回的所有 Map.Entry 对，表示他们产生时的映射关系快照。它们不 支持 Entry.setValue 方法。（注意，根据所需效果，可以使用 put、putIfAbsent 或 replace 更改关联映射中的映射关系。）

请注意，与在大多数 collection 中不同，这里的 size 方法不是 一个固定时间 (constant-time) 操作。因为这些映射的异步特性，确定元素的当前数目需要遍历元素。此外，批量操作 putAll、equals 和 clear 并不 保证能以原子方式 (atomically) 执行。例如，与 putAll 操作一起并发操作的迭代器只能查看某些附加元素。

此类及其视图和迭代器实现 Map 和 Iterator 接口的所有可选 方法。与大多数其他并发 collection 一样，此类不 允许使用 null 键或值，因为无法可靠地区分 null 返回值与不存在的元素值。

此类是 Java Collections Framework 的成员。

从以下版本开始：

1.6

另请参见：

序列化表格

嵌套类摘要

从类 java.util.AbstractMap 继承的嵌套类/接口

AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>

从接口 java.util.Map 继承的嵌套类/接口

Map.Entry<K,V>

构造方法摘要

ConcurrentSkipListMap()
构造一个新的空映射，该映射按照键的自然顺序进行排序。

ConcurrentSkipListMap(Comparator<? super K> comparator)
构造一个新的空映射，该映射按照指定的比较器进行排序。

ConcurrentSkipListMap(Map<? extends K,? extends V> m)
构造一个新映射，该映射所包含的映射关系与给定映射包含的映射关系相同，并按照键的自然顺序进行排序。

ConcurrentSkipListMap(SortedMap<K,? extends V> m)
构造一个新映射，该映射所包含的映射关系与指定的有序映射包含的映射关系相同，使用的顺序也相同。

方法摘要

Map.Entry<K,V>	ceilingEntry(K key) 返回与大于等于给定键的最小键关联的键-值映射关系；如果不存在这样的条目，则返回 null。
K	ceilingKey(K key) 返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
void	clear() 从此映射中移除所有映射关系。
ConcurrentSkipListMap<K,V>	clone() 返回此 ConcurrentSkipListMap 实例的浅表副本。
Comparator<? super K>	comparator() 返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
boolean	containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
boolean	containsValue(Object value) 如果此映射为指定值映射一个或多个键，则返回 true。
NavigableSet<K>	descendingKeySet() 返回此映射中所包含键的逆序 NavigableSet 视图。
ConcurrentNavigableMap<K,V>	descendingMap() 返回此映射中所包含映射关系的逆序视图。
Set<Map.Entry<K,V>>	entrySet() 返回此映射中所包含的映射关系的 Set 视图。
boolean	equals(Object o) 比较指定对象与此映射的相等性。
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。
ConcurrentNavigableMap<K,V>	headMap(K toKey) 返回此映射的部分视图，其键值严格小于 toKey。
ConcurrentNavigableMap<K,V>	headMap(K toKey, boolean inclusive) 返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。
Map.Entry<K,V>	higherEntry(K key) 返回与严格大于给定键的最小键关联的键-值映射关系；如果不存在这样的键，则返回 null。
K	higherKey(K key) 返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
boolean	isEmpty() 如果此映射未包含键-值映射关系，则返回 true。
NavigableSet<K>	keySet() 返回此映射中所包含键的 NavigableSet 视图。
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) 将指定值与此映射中的指定键关联。
V	putIfAbsent(K key, V value) 如果指定键已经不再与某个值相关联，则将它与给定值关联。
V	remove(Object key) 从此映射中移除指定键的映射关系（如果存在）。
boolean	remove(Object key, Object value) 只有目前将键的条目映射到给定值时，才移除该键的条目。
V	replace(K key, V value) 只有目前将键的条目映射到某一值时，才替换该键的条目。
boolean	replace(K key, V oldValue, V newValue) 只有目前将键的条目映射到给定值时，才替换该键的条目。
int	size() 返回此映射中的键-值映射关系数。
ConcurrentNavigableMap<K,V>	subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 返回此映射的部分视图，其键的范围从 fromKey 到 toKey。
ConcurrentNavigableMap<K,V>	subMap(K fromKey, K toKey) 返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。
ConcurrentNavigableMap<K,V>	tailMap(K fromKey) 返回此映射的部分视图，其键大于等于 fromKey。
ConcurrentNavigableMap<K,V>	tailMap(K fromKey, boolean inclusive) 返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。
Collection<V>	values() 返回此映射中所包含值的 Collection 视图。

从类 java.util.AbstractMap 继承的方法

hashCode, putAll, toString

从类 java.lang.Object 继承的方法

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

从接口 java.util.Map 继承的方法

hashCode, putAll

构造方法详细信息

ConcurrentSkipListMap

public ConcurrentSkipListMap()

构造一个新的空映射，该映射按照键的自然顺序进行排序。

ConcurrentSkipListMap

public ConcurrentSkipListMap(Comparator<? super K> comparator)

构造一个新的空映射，该映射按照指定的比较器进行排序。

参数：

comparator - 用于对此映射进行排序的比较器。如果此参数为 null，则使用键的自然顺序。

ConcurrentSkipListMap

public ConcurrentSkipListMap(Map<? extends K,? extends V> m)

构造一个新映射，该映射所包含的映射关系与给定映射包含的映射关系相同，并按照键的自然顺序进行排序。

参数：

m - 映射关系将被存放在此映射中的映射

抛出：

ClassCastException - 如果 m 中的键不是 Comparable，或者无法相互比较

NullPointerException - 如果指定的映射或者它的任何键或值为 null

ConcurrentSkipListMap

public ConcurrentSkipListMap(SortedMap<K,? extends V> m)

构造一个新映射，该映射所包含的映射关系与指定的有序映射包含的映射关系相同，使用的顺序也相同。

参数：

m - 映射关系将被存放在此映射中的有序映射，其比较器用于对此映射进行排序

抛出：

NullPointerException - 如果指定的有序映射或者它的任何键或值为 null

方法详细信息

clone

public ConcurrentSkipListMap<K,V> clone()

返回此 ConcurrentSkipListMap 实例的浅表副本。（不复制键和值本身。）

覆盖：

类 AbstractMap<K,V> 中的 clone

返回：

此映射的浅表副本

另请参见：

Cloneable

containsKey

public boolean containsKey(Object key)

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

指定者：

接口 Map<K,V> 中的 containsKey

覆盖：

类 AbstractMap<K,V> 中的 containsKey

参数：

key - 测试是否存在于此映射中的键

返回：

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

抛出：

ClassCastException - 如果指定键无法与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

get

public V get(Object key)

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

更确切地讲，如果此映射包含从键 k 到值 v 的映射关系，根据映射的顺序，key 与 k 比较起来相等，那么此方法返回 v；否则返回 null。（最多只能有一个这样的映射关系）。

指定者：

接口 Map<K,V> 中的 get

覆盖：

类 AbstractMap<K,V> 中的 get

参数：

key - 要返回其关联值的键

返回：

指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null

抛出：

ClassCastException - 如果指定键无法与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

put

public V put(K key,
             V value)

将指定值与此映射中的指定键关联。如果映射以前包含了一个该键的映射关系，那么将替换旧值。

指定者：

接口 Map<K,V> 中的 put

覆盖：

类 AbstractMap<K,V> 中的 put

参数：

key - 与指定值关联的键

value - 与指定键关联的值

返回：

以前与指定键关联的值；如果该键没有映射关系，则返回 null

抛出：

ClassCastException - 如果指定键无法与映射中的当前值进行比较

NullPointerException - 如果指定键或值为 null

remove

public V remove(Object key)

从此映射中移除指定键的映射关系（如果存在）。

指定者：

接口 Map<K,V> 中的 remove

覆盖：

类 AbstractMap<K,V> 中的 remove

参数：

key - 映射关系应该被移除的键

返回：

以前与指定键关联的值；如果该键没有映射关系，则返回 null

抛出：

ClassCastException - 如果指定键无法与映射中的当前值进行比较

NullPointerException - 如果指定键为 null

containsValue

public boolean containsValue(Object value)

如果此映射为指定值映射一个或多个键，则返回 true。此操作所需的时间与映射的大小呈线性关系。

指定者：

接口 Map<K,V> 中的 containsValue

覆盖：

类 AbstractMap<K,V> 中的 containsValue

参数：

value - 测试是否存在于此映射中的值

返回：

如果存在对 value 的映射关系，则返回 true；否则返回 false

抛出：

NullPointerException - 如果指定的值为 null

size

public int size()

返回此映射中的键-值映射关系数。如果此映射包含的元素数大于 Integer.MAX_VALUE，则返回 Integer.MAX_VALUE。

请注意，与在大多数 collection 中不同，此方法在这不是 一个固定时间操作。因为这些映射的异步特性，确定元素的当前数目需要遍历元素以计算其数目。此外，在执行此方法期间可以更改大小，在这种情况下，返回的结果将不准确。因此，此方法在并发应用程序中通常不是很有用。

指定者：

接口 Map<K,V> 中的 size

覆盖：

类 AbstractMap<K,V> 中的 size

返回：

此映射中的元素数

isEmpty

public boolean isEmpty()

如果此映射未包含键-值映射关系，则返回 true。

指定者：

接口 Map<K,V> 中的 isEmpty

覆盖：

类 AbstractMap<K,V> 中的 isEmpty

返回：

如果此映射未包含键-值映射关系，则返回 true

clear

public void clear()

从此映射中移除所有映射关系。

指定者：

接口 Map<K,V> 中的 clear

覆盖：

类 AbstractMap<K,V> 中的 clear

keySet

public NavigableSet<K> keySet()

返回此映射中所包含键的 NavigableSet 视图。set 的迭代器按升序返回键。set 受映射支持，因此对映射的更改可在 set 中反映出来，反之亦然。set 支持元素移除，即通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

视图的 iterator 是一个不会抛出 ConcurrentModificationException 的“弱一致”迭代器，能确保遍历构造迭代器后存在的所有元素，并且可以（但并不保证）反映构造后的所有修改。

此方法等效于方法 navigableKeySet。

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 keySet

指定者：

接口 Map<K,V> 中的 keySet

指定者：

接口 SortedMap<K,V> 中的 keySet

覆盖：

类 AbstractMap<K,V> 中的 keySet

返回：

此映射中键的可导航 set 视图

navigableKeySet

public NavigableSet<K> navigableKeySet()

从接口 ConcurrentNavigableMap 复制的描述

返回此映射中所包含键的 NavigableSet 视图。set 的迭代器按升序返回键。set 受映射支持，因此对映射的更改将反映在 set 中，反之亦然。set 支持元素移除，即通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

视图的 iterator 是一个不会抛出 ConcurrentModificationException 的“弱一致”迭代器，能确保遍历构造迭代器后存在的所有元素，并且可以（但并不保证）反映构造后的所有修改。

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 navigableKeySet

指定者：

接口 NavigableMap<K,V> 中的 navigableKeySet

返回：

此映射中键的可导航 set 视图

values

public Collection<V> values()

返回此映射中所包含值的 Collection 视图。collection 的迭代器将按相应键的升序返回值。collection 受映射支持，所以对映射的更改可在此 collection 中反映出来，反之亦然。collection 支持元素移除，通过 Iterator.remove、Collection.remove、removeAll、retainAll 和 clear 操作，可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

视图的 iterator 是一个不会抛出 ConcurrentModificationException 的“弱一致”迭代器，能确保遍历构造迭代器后存在的所有元素，并且可以（但并不保证）反映构造后的所有修改。

指定者：

接口 Map<K,V> 中的 values

指定者：

接口 SortedMap<K,V> 中的 values

覆盖：

类 AbstractMap<K,V> 中的 values

返回：

此映射中包含的值的 collection 视图

entrySet

public Set<Map.Entry<K,V>> entrySet()

返回此映射中所包含的映射关系的 Set 视图。set 的迭代器按键的升序返回条目。set 受映射支持，因此对映射的更改可在 set 中反映出来，反之亦然。set 支持元素移除，通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作，可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

视图的 iterator 是一个不会抛出 ConcurrentModificationException 的“弱一致”迭代器，能确保遍历构造迭代器后存在的所有元素，并且可以（但并不保证）反映构造后的所有修改。

由 iterator.next() 返回的 Map.Entry 元素 不 支持 setValue 操作。

指定者：

接口 Map<K,V> 中的 entrySet

指定者：

接口 SortedMap<K,V> 中的 entrySet

指定者：

类 AbstractMap<K,V> 中的 entrySet

返回：

包含在此映射中的映射关系的 set 视图，它按键的升序排序

descendingMap

public ConcurrentNavigableMap<K,V> descendingMap()

从接口 ConcurrentNavigableMap 复制的描述

返回此映射中所包含映射关系的逆序视图。降序映射受此映射的支持，因此对此映射的更改将反映在降序映射中，反之亦然。

返回映射的顺序等于 Collections.reverseOrder(comparator())。表达式 m.descendingMap().descendingMap() 返回的 m 视图基本等效于 m。

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 descendingMap

指定者：

接口 NavigableMap<K,V> 中的 descendingMap

返回：

此映射的逆序视图

descendingKeySet

public NavigableSet<K> descendingKeySet()

从接口 ConcurrentNavigableMap 复制的描述

返回此映射中所包含键的逆序 NavigableSet 视图。set 的迭代器按降序返回键。set 受映射支持，因此对映射的更改将反映在 set 中，反之亦然。set 支持元素移除，即通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

视图的 iterator 是一个不会抛出 ConcurrentModificationException 的“弱一致”迭代器，能确保遍历构造迭代器后存在的所有元素，并且可以（但并不保证）反映构造后的所有修改。

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 descendingKeySet

指定者：

接口 NavigableMap<K,V> 中的 descendingKeySet

返回：

此映射中键的逆序可导航 set 视图

equals

public boolean equals(Object o)

比较指定对象与此映射的相等性。如果给定对象也是一个映射并且两个映射表示相同的映射关系，则返回 true。更确切地讲，如果 m1.entrySet().equals(m2.entrySet())，那么这两个映射 m1 和 m2 表示相同的映射关系。如果在执行该此方法期间并发地修改了某一个映射，则此操作返回的结果可能不符合实际。

指定者：

接口 Map<K,V> 中的 equals

覆盖：

类 AbstractMap<K,V> 中的 equals

参数：

o - 要与此映射进行相等性比较的对象

返回：

true 如果指定对象等于此映射

另请参见：

Object.hashCode(), Hashtable

putIfAbsent

public V putIfAbsent(K key,
                     V value)

如果指定键已经不再与某个值相关联，则将它与给定值关联。这等价于：

   if (!map.containsKey(key)) 
      return map.put(key, value);
  else
       return map.get(key);

除了原子地执行此操作之外。

指定者：

接口 ConcurrentMap<K,V> 中的 putIfAbsent

参数：

key - 与指定值相关联的键

value - 与指定键相关联的值

返回：

以前与指定键关联的值；如果没有该键的映射关系，则返回 null

抛出：

ClassCastException - 如果指定键无法与映射中的当前值进行比较

NullPointerException - 如果指定键或值为 null

remove

public boolean remove(Object key,
                      Object value)

只有目前将键的条目映射到给定值时，才移除该键的条目。这等效于：

   if (map.containsKey(key) && map.get(key).equals(value)) {
       map.remove(key);
       return true;
   } else return false;

不同之处在于该操作是以原子方式 (atomically) 执行的。

指定者：

接口 ConcurrentMap<K,V> 中的 remove

参数：

key - 与指定值相关联的键

value - 期望与指定键相关联的值

返回：

如果该值被移除，则返回 true

抛出：

ClassCastException - 如果指定键无法与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

只有目前将键的条目映射到给定值时，才替换该键的条目。这等效于：

   if (map.containsKey(key) && map.get(key).equals(oldValue)) {
       map.put(key, newValue);
       return true;
   } else return false;

不同之处在于该操作是以原子方式执行的。

指定者：

接口 ConcurrentMap<K,V> 中的 replace

参数：

key - 与指定值相关联的键

oldValue - 期望与指定键相关联的值

newValue - 与指定键相关联的值

返回：

如果该值被替换，则返回 true

抛出：

ClassCastException - 如果指定键无法与映射中的当前键进行比较

NullPointerException - 如果任何参数为 null

replace

public V replace(K key,
                 V value)

只有目前将键的条目映射到某一值时，才替换该键的条目。这等效于：

   if (map.containsKey(key)) {
       return map.put(key, value);
   } else return null;

不同之处在于该操作是以原子方式执行的。

指定者：

接口 ConcurrentMap<K,V> 中的 replace

参数：

key - 与指定值相关联的键

value - 与指定键相关联的值

返回：

以前与指定键关联的值；如果没有该键的映射关系，则返回 null

抛出：

ClassCastException - 如果指定键无法与映射中的当前值进行比较

NullPointerException - 如果指定键或值为 null

comparator

public Comparator<? super K> comparator()

从接口 SortedMap 复制的描述

返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。

指定者：

接口 SortedMap<K,V> 中的 comparator

返回：

用来对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null

firstKey

public K firstKey()

从接口 SortedMap 复制的描述

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

指定者：

接口 SortedMap<K,V> 中的 firstKey

返回：

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

抛出：

NoSuchElementException - 如果此映射为空

lastKey

public K lastKey()

从接口 SortedMap 复制的描述

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

指定者：

接口 SortedMap<K,V> 中的 lastKey

返回：

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

抛出：

NoSuchElementException - 如果此映射为空

subMap

public ConcurrentNavigableMap<K,V> subMap(K fromKey,
                                          boolean fromInclusive,
                                          K toKey,
                                          boolean toInclusive)

从接口 NavigableMap 复制的描述

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

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

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 subMap

指定者：

接口 NavigableMap<K,V> 中的 subMap

参数：

fromKey - 返回映射中键的低端点

fromInclusive - 如果低端点要包含在返回的视图中，则为 true

toKey - 返回映射中键的高端点

toInclusive - 如果高端点要包含在返回的视图中，则为 true

返回：

此映射的部分视图，其键范围从 fromKey 到 toKey

抛出：

ClassCastException - 如果不能使用此映射的比较器（如果映射没有比较器，则使用自然顺序）比较 fromKey 和 toKey。如果 fromKey 或 toKey 不能与映射中当前键进行比较，则实现可以（但不是必须）抛出此异常。

NullPointerException - 如果 fromKey 或 toKey 为 null

IllegalArgumentException - 如果 fromKey 大于 toKey；如果此映射本身有范围限制，并且 fromKey 或 toKey 位于范围的边界之外

headMap

public ConcurrentNavigableMap<K,V> headMap(K toKey,
                                           boolean inclusive)

从接口 NavigableMap 复制的描述

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

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

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 headMap

指定者：

接口 NavigableMap<K,V> 中的 headMap

参数：

toKey - 返回映射中键的高端点

inclusive - 如果高端点要包含在返回的视图中，则为 true

返回：

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

抛出：

ClassCastException - 如果 toKey 与此映射的比较器不兼容（如果映射没有比较器；如果 toKey 没有实现 Comparable）。如果 toKey 不能与映射中的当前键进行比较，则实现可以（但不是必须）抛出此异常。

NullPointerException - 如果 toKey 为 null

IllegalArgumentException - 如果此映射本身有范围限制，并且 toKey 位于范围的边界之外

tailMap

public ConcurrentNavigableMap<K,V> tailMap(K fromKey,
                                           boolean inclusive)

从接口 NavigableMap 复制的描述

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

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

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 tailMap

指定者：

接口 NavigableMap<K,V> 中的 tailMap

参数：

fromKey - 返回映射中键的低端点

inclusive - 如果低端点要包含在返回的视图中，则为 true

返回：

此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey

抛出：

ClassCastException - 如果 fromKey 与此映射的比较器不兼容（如果映射没有比较器；如果 fromKey 没有实现 Comparable）。如果 fromKey 不能与映射中的当前键进行比较，则实现可以（但不是必须）抛出此异常。

NullPointerException - 如果 fromKey 为 null

IllegalArgumentException - 如果此映射本身有范围限制，并且 fromKey 位于范围的边界之外

subMap

public ConcurrentNavigableMap<K,V> subMap(K fromKey,
                                          K toKey)

从接口 NavigableMap 复制的描述

返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。（如果 fromKey 和 toKey 相等，则返回映射为空。）返回的映射受此映射支持，所以在返回映射中的更改将反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。

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

等效于 subMap(fromKey, true, toKey, false)。

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 subMap

指定者：

接口 NavigableMap<K,V> 中的 subMap

指定者：

接口 SortedMap<K,V> 中的 subMap

参数：

fromKey - 返回映射中键的低端点（包括）

toKey - 返回映射中键的高端点（不包括）

返回：

此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）

抛出：

ClassCastException - 如果无法使用此映射的比较器（如果此映射没有比较器，则使用自然顺序）比较 fromKey 和 toKey。如果 fromKey 或 toKey 不能与映射中当前键进行比较，则实现可以（但不是必须）抛出此异常。

NullPointerException - 如果 fromKey 或 toKey 为 null

IllegalArgumentException - 如果 fromKey 大于 toKey；如果此映射本身有范围限制，并且 fromKey 或 toKey 位于范围的边界之外

headMap

public ConcurrentNavigableMap<K,V> headMap(K toKey)

从接口 NavigableMap 复制的描述

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

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

等效于 headMap(toKey, false)。

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 headMap

指定者：

接口 NavigableMap<K,V> 中的 headMap

指定者：

接口 SortedMap<K,V> 中的 headMap

参数：

toKey - 返回映射中键的高端点（不包括）

返回：

此映射的部分视图，该映射的键严格小于 toKey

抛出：

ClassCastException - 如果 toKey 与此映射的比较器不兼容（如果该映射没有比较器；如果 toKey 没有实现 Comparable）。如果 toKey 不能与映射中的当前键进行比较，则实现可以（但不是必须）抛出此异常。

NullPointerException - 如果 toKey 为 null

IllegalArgumentException - 如果此映射本身有范围限制，并且 toKey 位于范围的边界之外

tailMap

public ConcurrentNavigableMap<K,V> tailMap(K fromKey)

从接口 NavigableMap 复制的描述

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

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

等效于 tailMap(fromKey, true)。

指定者：

接口 ConcurrentNavigableMap<K,V> 中的 tailMap

指定者：

接口 NavigableMap<K,V> 中的 tailMap

指定者：

接口 SortedMap<K,V> 中的 tailMap

参数：

fromKey - 返回映射中键的低端点（包括）

返回：

此映射的部分视图，其键大于等于 fromKey

抛出：

ClassCastException - 如果 fromKey 与此映射的比较器不兼容（如果该映射没有比较器；如果 fromKey 没有实现 Comparable）。如果 fromKey 不能与映射中的当前键进行比较，则实现可以（但不是必须）抛出此异常。

NullPointerException - 如果 fromKey 为 null

IllegalArgumentException - 如果此映射本身有范围限制，并且 fromKey 位于范围的边界之外

lowerEntry

public Map.Entry<K,V> lowerEntry(K key)

返回与严格小于给定键的最大键关联的键-值映射关系；如果不存在这样的键，则返回 null。返回的条目不 支持 Entry.setValue 方法。

指定者：

接口 NavigableMap<K,V> 中的 lowerEntry

参数：

key - 键

返回：

最大键小于 key 的条目；如果不存在这样的键，则返回 null

抛出：

ClassCastException - 如果指定键不能与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

lowerKey

public K lowerKey(K key)

从接口 NavigableMap 复制的描述

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

指定者：

接口 NavigableMap<K,V> 中的 lowerKey

参数：

key - 键

返回：

小于 key 的最大键；如果不存在这样的键，则返回 null

抛出：

ClassCastException - 如果指定键不能与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

floorEntry

public Map.Entry<K,V> floorEntry(K key)

返回与小于等于给定键的最大键关联的键-值映射关系；如果不存在这样的键，则返回 null。返回的条目不 支持 Entry.setValue 方法。

指定者：

接口 NavigableMap<K,V> 中的 floorEntry

参数：

key - 键

返回：

最大键小于等于 key 的条目；如果不存在这样的键，则返回 null

抛出：

ClassCastException - 如果指定键不能与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

floorKey

public K floorKey(K key)

从接口 NavigableMap 复制的描述

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

指定者：

接口 NavigableMap<K,V> 中的 floorKey

参数：

key - 键

返回：

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

抛出：

ClassCastException - 如果指定键不能与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

ceilingEntry

public Map.Entry<K,V> ceilingEntry(K key)

返回与大于等于给定键的最小键关联的键-值映射关系；如果不存在这样的条目，则返回 null。返回的条目不 支持 Entry.setValue 方法。

指定者：

接口 NavigableMap<K,V> 中的 ceilingEntry

参数：

key - 键

返回：

最小键大于等于 key 的条目；如果不存在这样的键，则返回 null

抛出：

ClassCastException - 如果指定键不能与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

ceilingKey

public K ceilingKey(K key)

从接口 NavigableMap 复制的描述

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

指定者：

接口 NavigableMap<K,V> 中的 ceilingKey

参数：

key - 键

返回：

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

抛出：

ClassCastException - 如果指定键不能与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

higherEntry

public Map.Entry<K,V> higherEntry(K key)

返回与严格大于给定键的最小键关联的键-值映射关系；如果不存在这样的键，则返回 null。返回的条目不 支持 Entry.setValue 方法。

指定者：

接口 NavigableMap<K,V> 中的 higherEntry

参数：

key - 键

返回：

最小键大于 key 的条目；如果不存在这样的键，则返回 null

抛出：

ClassCastException - 如果指定键不能与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

higherKey

public K higherKey(K key)

从接口 NavigableMap 复制的描述

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

指定者：

接口 NavigableMap<K,V> 中的 higherKey

参数：

key - 键

返回：

大于 key 的最小键；如果不存在这样的键，则返回 null

抛出：

ClassCastException - 如果指定键不能与映射中的当前键进行比较

NullPointerException - 如果指定键为 null

firstEntry

public Map.Entry<K,V> firstEntry()

返回与此映射中的最小键关联的键-值映射关系；如果该映射为空，则返回 null。返回的条目不 支持 Entry.setValue 方法。

指定者：

接口 NavigableMap<K,V> 中的 firstEntry

返回：

带有最小键的条目；如果此映射为空，则返回 null

lastEntry

public Map.Entry<K,V> lastEntry()

返回与此映射中的最大键关联的键-值映射关系；如果该映射为空，则返回 null。返回的条目不 支持 Entry.setValue 方法。

指定者：

接口 NavigableMap<K,V> 中的 lastEntry

返回：

带有最大键的条目；如果此映射为空，则返回 null

pollFirstEntry

public Map.Entry<K,V> pollFirstEntry()

移除并返回与此映射中的最小键关联的键-值映射关系；如果该映射为空，则返回 null。返回的条目不 支持 Entry.setValue 方法。

指定者：

接口 NavigableMap<K,V> 中的 pollFirstEntry

返回：

此映射中被移除的第一个条目；如果此映射为空，则返回 null

pollLastEntry

public Map.Entry<K,V> pollLastEntry()

移除并返回与此映射中的最大键关联的键-值映射关系；如果该映射为空，则返回 null。返回的条目不 支持 Entry.setValue 方法。

指定者：

接口 NavigableMap<K,V> 中的 pollLastEntry

返回：

此映射中被移除的最后一个条目；如果此映射为空，则返回 null