Module java.base

软件包 java.util.concurrent

Class ConcurrentSkipListMap<K,V>

java.lang.Object

java.util.AbstractMap<K,V>

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

参数类型

K - 由此地图维护的键的类型

V - 映射值的类型

All Implemented Interfaces:

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实现。 该地图是根据排序natural ordering其密钥，或通过Comparator在地图创建时提供，这取决于所使用的构造方法。

这个类实现的并发变种SkipLists提供预期平均log（n）的时间成本，为containsKey ， get ， put和remove操作及其变体。 插入，删除，更新和访问操作由多个线程并发执行安全地执行。

迭代器和拼接器是weakly consistent 。

升序关键排序视图及其迭代器比降序更快。

通过此类中的方法返回的全部Map.Entry对，其视图表示生成时映射的快照。 他们不支持Entry.setValue方法。 （不过要注意的是可以利用改变相关的地图映射put ， putIfAbsent ，或replace ，取决于你到底需要哪些效果。）

请注意，与大多数集合不同， size方法不是一个常时操作。 由于这些映射的异步性质，确定当前元素数量需要遍历元素，因此如果在遍历期间修改此集合，则可能会报告不准确的结果。 此外，该批量操作putAll ， equals ， toArray ， containsValue和clear待原子方式执行， 不能保证。 例如，与putAll操作同时运行的迭代器可能仅查看一些添加的元素。

该类及其视图和迭代器实现了Map和Iterator接口的所有可选方法。 与大多数其他并发集合，这个类不允许使用null键或值，因为有些空返回值不能从存在的元素的可靠地区分。

这个班是Java Collections Framework的会员。

从以下版本开始：

1.6

另请参见：

Serialized Form

Nested Class Summary

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

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

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K,V>

构造方法摘要

构造方法

Constructor	描述
ConcurrentSkipListMap()	构造一个新的，空的地图，按照natural ordering的按键进行排序。
ConcurrentSkipListMap(Comparator<? super K> comparator)	构造一个新的，空的地图，根据指定的比较器进行排序。
ConcurrentSkipListMap(Map<? extends K,? extends V> m)	构造一个包含与给定地图相同的映射的新地图，根据密钥的natural ordering进行排序。
ConcurrentSkipListMap(SortedMap<K,? extends V> m)	构造一个包含相同映射并使用与指定排序映射相同顺序的新映射。

方法摘要

Modifier and Type	方法	描述
Map.Entry<K,V>	ceilingEntry(K key)	返回与大于或等于给定键的最小键相关联的键值映射，如果没有 null则 null 。
K	ceilingKey(K key)	返回大于或等于给定键的 null键，如果没有此键，则 null 。
void	clear()	从这张地图中删除所有的映射。
ConcurrentSkipListMap<K,V>	clone()	返回此 ConcurrentSkipListMap实例的浅拷贝。
Comparator<? super K>	comparator()	返回用于订购此地图中的键的比较器，或null如果此地图使用其键的natural ordering 。
V	compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)	尝试计算指定键的映射及其当前映射值（如果没有当前映射，则 null ）。
V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)	如果指定的键尚未与值相关联，则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非是 null 。
V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)	如果存在指定键的值，则尝试计算给出键的新映射及其当前映射值。
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 。
void	forEach(BiConsumer<? super K,? super V> action)	对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
V	get(Object key)	返回指定键映射到的值，如果此映射不包含该键的映射，则返回 null 。
V	getOrDefault(Object key, V defaultValue)	返回指定键映射到的值或给定的defaultValue，如果该映射不包含该键的映射。
ConcurrentNavigableMap<K,V>	headMap(K toKey)	返回此地图部分的视图，其密钥严格小于 toKey 。
ConcurrentNavigableMap<K,V>	headMap(K toKey, boolean inclusive)	返回该地图部分的视图，其键值小于（或等于，如果 inclusive为真） 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 。
V	merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)	如果指定的键尚未与值相关联，则将其与给定值相关联。
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)	仅当当前映射到给定值时才替换密钥的条目。
void	replaceAll(BiFunction<? super K,? super V,? extends V> function)	将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
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为真） fromKey 。
Collection<V>	values()	返回此地图中包含的值的Collection视图。

Methods inherited from class java.util.AbstractMap

hashCode, putAll, toString

Methods inherited from interface java.util.Map

entry, hashCode, of, of, of, of, of, of, of, of, of, of, of, ofEntries, putAll

Methods inherited from class java.lang.Object

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

构造方法详细信息

ConcurrentSkipListMap

public ConcurrentSkipListMap()

构造一个新的，空的地图，按照natural ordering的按键进行排序。

ConcurrentSkipListMap

public ConcurrentSkipListMap(Comparator<? super K> comparator)

构造一个新的，空的地图，根据指定的比较器进行排序。

参数

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

ConcurrentSkipListMap

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

构造一个包含与给定地图相同的映射的新地图，按照密钥的natural ordering进行排序。

参数

m - 其映射将放置在此映射中的映射

异常

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

NullPointerException - 如果指定的地图或其任何键或值为空

ConcurrentSkipListMap

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

构造一个包含相同映射并使用与指定排序映射相同顺序的新映射。

参数

m - 其映射将被放置在此映射中的排序映射，并且其比较器将用于对该映射进行排序

异常

NullPointerException - 如果指定的排序映射或其任何键或值为空

方法详细信息

clone

public ConcurrentSkipListMap<K,V> clone()

返回此ConcurrentSkipListMap实例的浅拷贝。 （键和值本身不被克隆。）

重写：

clone中的 AbstractMap<K,V>

结果

这张地图的浅拷贝

另请参见：

Cloneable

containsKey

public boolean containsKey(Object key)

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

Specified by:

containsKey在接口 Map<K,V>

重写：

containsKey在 AbstractMap<K,V>

参数

key - 要在此地图中存在的密钥要进行测试

结果

true如果此映射包含指定键的映射

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

get

public V get(Object key)

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

更正式地，如果此映射包含从密钥映射k到值v使得key比较等于k根据地图的排序，则此方法返回v ; 否则返回null 。 （最多可以有一个这样的映射。）

Specified by:

get在接口 Map<K,V>

重写：

get在 AbstractMap<K,V>

参数

key - 要返回其关联值的键

结果

指定键映射到的值，如果此映射不包含键的映射， null

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

getOrDefault

public V getOrDefault(Object key,
                      V defaultValue)

返回指定键映射到的值或给定的defaultValue，如果该映射不包含该键的映射。

Specified by:

getOrDefault在接口 ConcurrentMap<K,V>

Specified by:

getOrDefault在接口 Map<K,V>

参数

key - 关键

defaultValue - 如果此映射不包含给定键的映射，则返回的值

结果

键的映射，如果存在; 否则为defaultValue

异常

NullPointerException - 如果指定的键为空

从以下版本开始：

1.8

put

public V put(K key,
             V value)

将指定的值与此映射中的指定键相关联。 如果地图先前包含了该键的映射，则替换旧值。

Specified by:

put在接口 Map<K,V>

重写：

put在 AbstractMap<K,V>

参数

key - 与其相关联的指定值的键

value - 与指定键相关联的值

结果

与指定键相关联的上一个值，如果没有键的映射， null

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键或值为空

remove

public V remove(Object key)

从该地图中删除指定键的映射（如果存在）。

Specified by:

remove在接口 Map<K,V>

重写：

remove中的 AbstractMap<K,V>

参数

key - 应该删除映射的键

结果

与指定键相关联的上一个值，如果没有键的映射， null

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

containsValue

public boolean containsValue(Object value)

如果该地图将一个或多个键映射到指定的值，则返回true 。 此操作需要在地图大小的时间线性。 此外，在执行此方法期间，地图可能会发生更改，在这种情况下，返回的结果可能不准确。

Specified by:

containsValue在接口 Map<K,V>

重写：

containsValue中的 AbstractMap<K,V>

参数

value - 要在此地图中存在的值要进行测试

结果

true如果映射到value存在; false否则

异常

NullPointerException - 如果指定的值为null

size

public int size()

返回此地图中键值映射的数量。 如果此地图包含Integer.MAX_VALUE元素，则返回Integer.MAX_VALUE 。

请注意，与大多数集合不同，此方法不是一个常时操作。 由于这些映射的异步性质，确定当前数量的元素需要遍历它们才能对它们进行计数。 此外，在执行此方法期间，大小可能会发生更改，在这种情况下，返回的结果将不准确。 因此，这种方法在并发应用程序中通常不是很有用。

Specified by:

size在接口 Map<K,V>

重写：

size在 AbstractMap<K,V>

结果

该地图中的元素数量

isEmpty

public boolean isEmpty()

如果此映射不包含键值映射，则返回 true 。

Specified by:

isEmpty在接口 Map<K,V>

重写：

isEmpty在 AbstractMap<K,V>

结果

true如果此映射不包含键值映射

clear

public void clear()

从这张地图中删除所有的映射。

Specified by:

clear在接口 Map<K,V>

重写：

clear在 AbstractMap<K,V>

computeIfAbsent

public V computeIfAbsent(K key,
                         Function<? super K,? extends V> mappingFunction)

如果指定的键尚未与值相关联，则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非是null 。 该函数不保证一旦原子仅当值不存在施加。

Specified by:

computeIfAbsent在接口 ConcurrentMap<K,V>

Specified by:

computeIfAbsent在接口 Map<K,V>

参数

key - 指定值与之关联的键

mappingFunction - 计算值的函数

结果

与指定键相关联的当前（现有或计算）值，如果计算值为空，则为null

异常

NullPointerException - 如果指定的键为空或mappingFunction为空

从以下版本开始：

1.8

computeIfPresent

public V computeIfPresent(K key,
                          BiFunction<? super K,? super V,? extends V> remappingFunction)

如果存在指定键的值，则尝试计算给出键的新映射及其当前映射值。 该功能不能保证原子应用一次。

Specified by:

computeIfPresent在接口 ConcurrentMap<K,V>

Specified by:

computeIfPresent在接口 Map<K,V>

参数

key - 值可以与之相关联的键

remappingFunction - 计算值的函数

结果

与指定键相关的新值，如果没有则为null

异常

NullPointerException - 如果指定的键为null或 NullPointerException为空

从以下版本开始：

1.8

compute

public V compute(K key,
                 BiFunction<? super K,? super V,? extends V> remappingFunction)

尝试计算指定密钥及其当前映射值的映射（如果没有当前映射，则null ）。 该功能不能保证原子应用一次。

Specified by:

compute在接口 ConcurrentMap<K,V>

Specified by:

compute在接口 Map<K,V>

参数

key - 要与其关联的指定值的键

remappingFunction - 计算值的函数

结果

与指定键相关的新值，如果没有则为null

异常

NullPointerException - 如果指定的键为空或 NullPointerException为空

从以下版本开始：

1.8

merge

public V merge(K key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)

如果指定的键尚未与值相关联，则将其与给定值相关联。 否则，使用给定的重映射函数的结果替换该值，或者如果为null ，则将其null 。 该功能不能保证原子应用一次。

Specified by:

merge在接口 ConcurrentMap<K,V>

Specified by:

merge在接口 Map<K,V>

参数

key - 指定值与之关联的键

value - 缺席时使用的值

remappingFunction - 重新计算值（如果存在）的功能

结果

与指定键相关的新值，如果没有则为null

异常

NullPointerException - 如果指定的键或值为空或 NullPointerException为空

从以下版本开始：

1.8

keySet

public NavigableSet<K> keySet()

返回此地图中包含的键的NavigableSet视图。

该集合的迭代器按升序返回密钥。 该集的spliterator另外报告Spliterator.CONCURRENT ， Spliterator.NONNULL ， Spliterator.SORTED和Spliterator.ORDERED ，与被按键的升序的顺序相遇。 该spliterator的比较（见Spliterator.getComparator() ）是null如果映射的比较（见comparator() ）是null 。 否则，拼接器的比较器与地图的比较器相同或者施加相同的总排序。

该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。 该组支持元件移除，即从映射中相应的映射，经由Iterator.remove ， Set.remove ， removeAll ， retainAll ，和clear操作。 它不支持add或addAll操作。

视图的迭代器和拼接器是weakly consistent 。

该方法等同于方法navigableKeySet 。

Specified by:

keySet在接口 ConcurrentNavigableMap<K,V>

Specified by:

keySet在接口 Map<K,V>

Specified by:

keySet在接口 SortedMap<K,V>

重写：

keySet中的 AbstractMap<K,V>

结果

该地图中的键的可导航集合视图

navigableKeySet

public NavigableSet<K> navigableKeySet()

描述从接口ConcurrentNavigableMap复制

返回此地图中包含的键的NavigableSet视图。 该集合的迭代器按升序返回密钥。 该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。 该组支持元件移除，即从映射中相应的映射，经由Iterator.remove ， Set.remove ， removeAll ， retainAll ，和clear操作。 它不支持add或addAll操作。

视图的迭代器和拼接器是weakly consistent 。

Specified by:

navigableKeySet接口 ConcurrentNavigableMap<K,V>

Specified by:

navigableKeySet接口 NavigableMap<K,V>

结果

该地图中的键的可导航集合视图

values

public Collection<V> values()

返回此地图中包含的值的Collection视图。

集合的迭代器按照相应键的升序返回值。 藏品的spliterator另外报告Spliterator.CONCURRENT ， Spliterator.NONNULL和Spliterator.ORDERED ，与正在提升相应的按键顺序的遭遇订单。

集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。 该collection支持元素移除，即从映射中相应的映射，经由Iterator.remove ， Collection.remove ， removeAll ， retainAll和clear操作。 它不支持add或addAll操作。

视图的迭代器和拼接器是weakly consistent 。

Specified by:

values接口 Map<K,V>

Specified by:

values在接口 SortedMap<K,V>

重写：

values在 AbstractMap<K,V>

结果

该地图中包含的值的集合视图

entrySet

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

返回此地图中包含的映射的Set视图。

集合的迭代器按升序键顺序返回条目。 该集的spliterator另外报告Spliterator.CONCURRENT ， Spliterator.NONNULL ， Spliterator.SORTED和Spliterator.ORDERED ，与被按键的升序的顺序相遇。

该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。 该组支持元件移除，即从映射中相应的映射，经由Iterator.remove ， Set.remove ， removeAll ， retainAll和clear操作。 它不支持add或addAll操作。

视图的迭代器和拼接器是weakly consistent 。

由iterator或spliterator遍历的Map.Entry元素不支持setValue操作。

Specified by:

entrySet在接口 Map<K,V>

Specified by:

entrySet在接口 SortedMap<K,V>

Specified by:

entrySet在 AbstractMap<K,V>

结果

该地图中包含的映射的集合视图，按升序排序

descendingMap

public ConcurrentNavigableMap<K,V> descendingMap()

说明从界面ConcurrentNavigableMap复制

返回此映射中包含的映射的反向排序视图。 降序地图由该地图支持，所以对地图的更改反映在降序地图中，反之亦然。

返回的地图的订单等价于Collections.reverseOrder (comparator()) 。 表达m.descendingMap().descendingMap()返回一个视图的m实质上等同于m 。

Specified by:

descendingMap在接口 ConcurrentNavigableMap<K,V>

Specified by:

descendingMap在接口 NavigableMap<K,V>

结果

这张地图的倒序视图

descendingKeySet

public NavigableSet<K> descendingKeySet()

描述从接口ConcurrentNavigableMap复制

返回此地图中包含的键的相反顺序NavigableSet 。 集合的迭代器按降序返回密钥。 该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。 该组支持元件移除，即从映射中相应的映射，经由Iterator.remove ， Set.remove ， removeAll ， retainAll ，和clear操作。 它不支持add或addAll操作。

视图的迭代器和拼接器是weakly consistent 。

Specified by:

descendingKeySet在接口 ConcurrentNavigableMap<K,V>

Specified by:

descendingKeySet在接口 NavigableMap<K,V>

结果

该地图中的键的反向导航设置视图

equals

public boolean equals(Object o)

将指定的对象与此映射进行比较以获得相等性。 如果给定的对象也是一个地图，并且两个地图代表相同的映射，则返回true 。 更正式地，如果m1.entrySet().equals(m2.entrySet()) ，两个地图m1和m2表示相同的映射。 如果在执行此方法期间同时修改了映射，则此操作可能会返回误导结果。

Specified by:

equals在接口 Map<K,V>

重写：

equals中的 AbstractMap<K,V>

参数

o - 要与此地图相等的对象进行比较

结果

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

另请参见：

Object.hashCode() ， HashMap

putIfAbsent

public V putIfAbsent(K key,
                     V value)

如果指定的键尚未与值相关联，则将其与给定值相关联。 这相当于，对于这个map ：

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

除了动作以原子方式执行。

Specified by:

putIfAbsent接口 ConcurrentMap<K,V>

Specified by:

putIfAbsent在接口 Map<K,V>

参数

key - 指定值与之关联的键

value - 与指定键相关联的值

结果

与指定键相关联的上一个值，如果没有键的映射， null

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键或值为空

remove

public boolean remove(Object key,
                      Object value)

仅当当前映射到给定值时才删除密钥的条目。 这相当于，对于这个map ：

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

除了动作以原子方式执行。

Specified by:

remove在接口 ConcurrentMap<K,V>

Specified by:

remove在接口 Map<K,V>

参数

key - 与指定值相关联的键

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

结果

true如果该值被删除

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

replace

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

仅当当前映射到给定值时才替换密钥的条目。 这相当于，对于这个map ：

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

除了动作以原子方式执行。

Specified by:

replace接口 ConcurrentMap<K,V>

Specified by:

replace在接口 Map<K,V>

参数

key - 与指定值相关联的键

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

newValue - 与指定键相关联的值

结果

true如果该值被替换

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果任何参数为空

replace

public V replace(K key,
                 V value)

仅当当前映射到某个值时才替换该项的条目。 这相当于，对于这个map ：

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

除了动作以原子方式执行。

Specified by:

replace在接口 ConcurrentMap<K,V>

Specified by:

replace在接口 Map<K,V>

参数

key - 与指定值相关联的键

value - 要与指定键相关联的值

结果

与指定键相关联的上一个值，如果没有键的映射， 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 - 如果这张地图是空的

lastKey

public K lastKey()

描述从接口SortedMap复制

返回当前在此地图中的最后（最高）键。

Specified by:

lastKey接口 SortedMap<K,V>

结果

当前在此地图中的最后（最高）键

异常

NoSuchElementException - 如果这张地图是空的

subMap

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

描述从接口NavigableMap复制

返回此地图部分的视图，其关键字范围从fromKey到toKey 。 如果fromKey和toKey相等，则返回的地图为空，除非fromInclusive和toInclusive都为真。 返回的地图由此地图支持，因此返回的地图中的更改将反映在该地图中，反之亦然。 返回的地图支持该地图支持的所有可选地图操作。

返回的地图将抛出一个IllegalArgumentException ，试图在其范围之外插入一个键，或者构建一个其端点位于其范围之外的子地图。

Specified by:

subMap在接口 ConcurrentNavigableMap<K,V>

Specified by:

subMap在接口 NavigableMap<K,V>

参数

fromKey - 返回地图中键的低端点

fromInclusive - true如果 true低端点包括在返回视图中

toKey - 返回地图中键的高端点

toInclusive - true如果 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为真） toKey 。 返回的地图由此地图支持，因此返回的地图中的更改将反映在该地图中，反之亦然。 返回的地图支持该地图支持的所有可选地图操作。

返回的地图将抛出一个IllegalArgumentException ，试图在其范围之外插入一个键。

Specified by:

headMap在接口 ConcurrentNavigableMap<K,V>

Specified by:

headMap在接口 NavigableMap<K,V>

参数

toKey - 返回地图中键的高端点

inclusive - true如果 true高端点包含在返回视图中

结果

键的小于（或等于，如果为 inclusive为真）的地图部分的视图） toKey

异常

ClassCastException - 如果toKey与该地图的比较器不兼容（或者如果地图没有比较器，如果toKey不实现Comparable ）。 如果toKey无法与当前在地图中的键进行比较，则实施可能但不是必须抛出此异常。

NullPointerException - 如果 toKey为空

IllegalArgumentException - 如果该地图本身有限制范围，而 toKey位于范围的范围之外

tailMap

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

说明从接口NavigableMap复制

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

返回的地图将抛出一个IllegalArgumentException ，试图在其范围之外插入一个键。

Specified by:

tailMap在接口 ConcurrentNavigableMap<K,V>

Specified by:

tailMap在接口 NavigableMap<K,V>

参数

fromKey - 返回地图中键的低端点

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

结果

该地图的部分的视图，其键大于（或等于，如果 inclusive为真） fromKey

异常

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

NullPointerException - 如果 fromKey为空

IllegalArgumentException - 如果此地图本身有限制范围，并且 fromKey位于范围界限之外

subMap

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

描述从接口NavigableMap复制

返回此地图部分的视图，其关键字范围从fromKey （含）到toKey ，独占。 （如果fromKey和toKey相等，则返回的地图为空。）返回的地图由该地图支持，因此返回地图中的更改将反映在该地图中，反之亦然。 返回的地图支持该地图支持的所有可选地图操作。

返回的地图会抛出一个IllegalArgumentException ，试图在其范围之外插入一个键。

相当于subMap(fromKey, true, toKey, false) 。

Specified by:

subMap在接口 ConcurrentNavigableMap<K,V>

Specified by:

subMap在接口 NavigableMap<K,V>

Specified by:

subMap在接口 SortedMap<K,V>

参数

fromKey - 返回地图中的键的低端点（含）

toKey - 返回地图中的键的高端点（独占）

结果

该地图的部分视图，其关键范围从 fromKey （含）到 toKey ，独占

异常

ClassCastException - 如果fromKey和toKey无法使用该地图的比较器相互比较（或者，如果地图没有比较器，则使用自然排序）。 如果fromKey或toKey无法与当前在地图中的键进行比较，则实施可能但不是必须抛出此异常。

NullPointerException - 如果 fromKey或 toKey为空

IllegalArgumentException - 如果fromKey大于toKey ; 或者如果此地图本身具有限制范围，并且fromKey或toKey位于范围范围之外

headMap

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

说明从接口NavigableMap复制

返回该地图的部分密钥严格小于toKey 。 返回的地图由此地图支持，因此返回的地图中的更改将反映在该地图中，反之亦然。 返回的地图支持该地图支持的所有可选地图操作。

返回的地图会抛出一个IllegalArgumentException ，试图在其范围之外插入一个键。

相当于headMap(toKey, false) 。

Specified by:

headMap在接口 ConcurrentNavigableMap<K,V>

Specified by:

headMap在接口 NavigableMap<K,V>

Specified by:

headMap在接口 SortedMap<K,V>

参数

toKey - 返回地图中的键的高端点（独占）

结果

该地图的部分密钥严格小于 toKey

异常

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

NullPointerException - 如果 toKey为空

IllegalArgumentException - 如果此地图本身有限制范围，而 toKey位于范围范围之外

tailMap

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

说明从接口NavigableMap复制

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

返回的地图会抛出一个IllegalArgumentException ，试图在其范围之外插入一个键。

相当于tailMap(fromKey, true) 。

Specified by:

tailMap在接口 ConcurrentNavigableMap<K,V>

Specified by:

tailMap在接口 NavigableMap<K,V>

Specified by:

tailMap在接口 SortedMap<K,V>

参数

fromKey - 返回地图中的键的低端点（含）

结果

该地图的部分的视图，其键大于或等于 fromKey

异常

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

NullPointerException - 如果 fromKey为空

IllegalArgumentException - 如果该地图本身有限制范围，并且 fromKey位于范围界限之外

lowerEntry

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

返回与最大密钥相关联的密钥值映射严格小于给定密钥，如果没有这样的密钥，则null 。 返回的条目不支持Entry.setValue方法。

Specified by:

lowerEntry在接口 NavigableMap<K,V>

参数

key - 关键

结果

一个最大密钥小于 key的条目，如果没有这样的密钥， null

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

lowerKey

public K lowerKey(K key)

描述从接口NavigableMap复制

返回严格小于给定键的最大键，如果没有这样的键，则返回 null 。

Specified by:

lowerKey在接口 NavigableMap<K,V>

参数

key - 关键

结果

最大的钥匙小于 key ，或者是 null如果没有这样的钥匙

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

floorEntry

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

返回与小于或等于给定键的最大键相关联的键值映射，如果没有此键，则null 。 返回的条目不支持Entry.setValue方法。

Specified by:

floorEntry在接口 NavigableMap<K,V>

参数

key - 关键

结果

最大密钥小于或等于 key ，如果没有这样的密钥， null

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

floorKey

public K floorKey(K key)

说明从接口NavigableMap复制

返回小于或等于给定键的最大键，如果没有此键，则 null 。

Specified by:

floorKey接口 NavigableMap<K,V>

参数

key - 关键

结果

最大钥匙小于或等于 key ，或 null如果没有这样的钥匙

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

ceilingEntry

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

返回与大于或等于给定键的最小键相关联的键值映射，如果没有null则null 。 返回的条目不支持Entry.setValue方法。

Specified by:

ceilingEntry在接口 NavigableMap<K,V>

参数

key - 关键

结果

最小密钥大于或等于 key ，如果没有这样的密钥， null

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

ceilingKey

public K ceilingKey(K key)

说明从接口NavigableMap复制

返回大于或等于给定键的 null键，如果没有这样的键，则 null 。

Specified by:

ceilingKey在接口 NavigableMap<K,V>

参数

key - 关键

结果

最小键大于等于 key ，或 null如果没有这样的键

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

higherEntry

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

返回与最小键相关联的键值映射严格大于给定键，如果没有此键，则null 。 返回的条目不支持Entry.setValue方法。

Specified by:

higherEntry在接口 NavigableMap<K,V>

参数

key - 关键

结果

一个条目的最小键大于 key ，或 null如果没有这样的键

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

higherKey

public K higherKey(K key)

说明从界面NavigableMap复制

返回严格大于给定键的最小键，如果没有这样的键，则返回 null 。

Specified by:

higherKey在接口 NavigableMap<K,V>

参数

key - 关键

结果

最小键大于 key ，或 null如果没有这样的键

异常

ClassCastException - 如果指定的键不能与当前在地图中的键进行比较

NullPointerException - 如果指定的键为空

firstEntry

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

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

Specified by:

firstEntry在接口 NavigableMap<K,V>

结果

具有最少键的条目，如果此映射为空， null

lastEntry

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

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

Specified by:

lastEntry接口 NavigableMap<K,V>

结果

如果该地图为空，则该密钥的最大密钥为 null

pollFirstEntry

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

删除并返回与该地图中的最小键相关联的键值映射，如果地图为空，则null 。 返回的条目不支持Entry.setValue方法。

Specified by:

pollFirstEntry在接口 NavigableMap<K,V>

结果

该地图被删除的第一个条目，如果该地图为空， null

pollLastEntry

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

删除并返回与该地图中最大键相关联的键值映射，如果地图为空，则null 。 返回的条目不支持Entry.setValue方法。

Specified by:

pollLastEntry接口 NavigableMap<K,V>

结果

删除该地图的最后一个条目，如果该地图为空， null

forEach

public void forEach(BiConsumer<? super K,? super V> action)

说明从界面ConcurrentMap复制

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

Specified by:

forEach在接口 ConcurrentMap<K,V>

Specified by:

forEach在接口 Map<K,V>

参数

action - 为每个条目执行的操作

replaceAll

public void replaceAll(BiFunction<? super K,? super V,? extends V> function)

描述从接口ConcurrentMap复制

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

Specified by:

replaceAll在接口 ConcurrentMap<K,V>

Specified by:

replaceAll在接口 Map<K,V>

参数

function - 应用于每个条目的功能