JavaTM 2 Platform
Standard Ed. 6

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

此类及此类视图中的方法返回的所有 Map.Entry 对,表示他们产生时的映射关系快照。它们 支持 Entry.setValue 方法。(注意,根据所需效果,可以使用 putputIfAbsentreplace 更改关联映射中的映射关系。)

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

此类及其视图和迭代器实现 MapIterator 接口的所有可选 方法。与大多数其他并发 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)
          返回此映射的部分视图,其键的范围从 fromKeytoKey
 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 的映射关系,根据映射的顺序,keyk 比较起来相等,那么此方法返回 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.removeSet.removeremoveAllretainAllclear 操作从映射中移除相应的映射关系。它不支持 addaddAll 操作。

视图的 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.removeSet.removeremoveAllretainAllclear 操作从映射中移除相应的映射关系。它不支持 addaddAll 操作。

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

指定者:
接口 ConcurrentNavigableMap<K,V> 中的 navigableKeySet
指定者:
接口 NavigableMap<K,V> 中的 navigableKeySet
返回:
此映射中键的可导航 set 视图

values

public Collection<V> values()
返回此映射中所包含值的 Collection 视图。collection 的迭代器将按相应键的升序返回值。collection 受映射支持,所以对映射的更改可在此 collection 中反映出来,反之亦然。collection 支持元素移除,通过 Iterator.removeCollection.removeremoveAllretainAllclear 操作,可从映射中移除相应的映射关系。它不支持 addaddAll 操作。

视图的 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.removeSet.removeremoveAllretainAllclear 操作,可从映射中移除相应的映射关系。它不支持 addaddAll 操作。

视图的 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.removeSet.removeremoveAllretainAllclear 操作从映射中移除相应的映射关系。它不支持 addaddAll 操作。

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

指定者:
接口 ConcurrentNavigableMap<K,V> 中的 descendingKeySet
指定者:
接口 NavigableMap<K,V> 中的 descendingKeySet
返回:
此映射中键的逆序可导航 set 视图

equals

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

指定者:
接口 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 复制的描述
返回此映射的部分视图,其键的范围从 fromKeytoKey。如果 fromKeytoKey 相等,则返回的映射为空,除非 fromExclusivetoExclusive 都为 true。返回的映射受此映射支持,因此返回映射中的更改将反映在此映射中,反之亦然。返回的映射支持此映射支持的所有可选映射操作。

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

指定者:
接口 ConcurrentNavigableMap<K,V> 中的 subMap
指定者:
接口 NavigableMap<K,V> 中的 subMap
参数:
fromKey - 返回映射中键的低端点
fromInclusive - 如果低端点要包含在返回的视图中,则为 true
toKey - 返回映射中键的高端点
toInclusive - 如果高端点要包含在返回的视图中,则为 true
返回:
此映射的部分视图,其键范围从 fromKeytoKey
抛出:
ClassCastException - 如果不能使用此映射的比较器(如果映射没有比较器,则使用自然顺序)比较 fromKeytoKey。如果 fromKeytoKey 不能与映射中当前键进行比较,则实现可以(但不是必须)抛出此异常。
NullPointerException - 如果 fromKeytoKey 为 null
IllegalArgumentException - 如果 fromKey 大于 toKey;如果此映射本身有范围限制,并且 fromKeytoKey 位于范围的边界之外

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(不包括)。(如果 fromKeytoKey 相等,则返回映射为空。)返回的映射受此映射支持,所以在返回映射中的更改将反映在此映射中,反之亦然。返回的映射支持此映射支持的所有可选映射操作。

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

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

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

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

JavaTM 2 Platform
Standard Ed. 6

提交错误或意见
有关更多的 API 参考资料和开发人员文档,请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述,以及总体概述、术语定义、使用技巧和工作代码示例。

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