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

另请参见：

序列化表格

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

版权所有 2007 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。