ConcurrentSkipListMap (Java Platform SE 8 )

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 and Description
`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	Method and Description
`Map.Entry<K,V>`	`ceilingEntry(K key)` 返回与大于或等于给定键的最小键相关联的键值映射，如果没有此项，则返回 `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` toKey。
`ConcurrentNavigableMap<K,V>`	`tailMap(K fromKey)` 返回此地图部分的视图，其键大于或等于 `fromKey` 。
`ConcurrentNavigableMap<K,V>`	`tailMap(K fromKey, boolean inclusive)` 返回此地图部分的视图，其键大于（或等于，如果 `inclusive`为true） `fromKey` 。
`Collection<V>`	`values()` 返回此地图中包含的值的`Collection`视图。

Methods inherited from class java.util.AbstractMap
hashCode, putAll, toString

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Map
hashCode, putAll

- 构造方法详细信息
  - 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 - 如果指定的值为空
  - 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或remappingFunction为空
    
    从以下版本开始：
    
    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 - 如果指定的键为null或remappingFunction为空
    
    从以下版本开始：
    
    1.8
  - merge
```
public V merge(K key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)
```
    如果指定的键尚未与值相关联，则将其与给定值相关联。否则，使用给定的重映射函数的结果替换该值，或者删除null 。该功能不能保证原子应用一次。
    
    Specified by:
    
    merge在界面 ConcurrentMap<K,V>
    
    Specified by:
    
    merge在接口 Map<K,V>
    
    参数
    
    key - 指定值与之关联的键
    
    value - 缺席时使用的值
    
    remappingFunction - 重新计算值（如果存在）的功能
    
    结果
    
    与指定键相关的新值，如果没有则为null
    
    异常
    
    NullPointerException - 如果指定的键或值为空或remappingFunction为空
    
    从以下版本开始：
    
    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.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)
```
    如果指定的键尚未与值相关联，请将其与给定值相关联。这相当于
```
   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)
```
    仅当当前映射到给定值时才删除密钥的条目。这相当于
```
   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)
```
    仅当当前映射到给定值时才替换密钥的条目。这相当于
```
   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)
```
    仅当当前映射到某个值时才替换该项的条目。这相当于
```
   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如果高端点要包含在返回的视图中
    
    结果
    
    该地图的部分视图从 fromKey到 toKey
    
    异常
    
    ClassCastException - 如果fromKey和toKey无法使用此映射的比较器彼此进行比较（或者，如果映射没有比较器，则使用自然排序）。如果fromKey或toKey无法与当前在地图中的键进行比较，则实施可能会但不是必须抛出此异常。
    
    NullPointerException - 如果 fromKey或 toKey为空
    
    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如果高端点要包括在返回的视图中
    
    结果
    
    关键字小于（或等于，如果 inclusive为真）的地图部分视图 toKey
    
    异常
    
    ClassCastException - 如果toKey与此地图的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器不兼容（或者如果映射没有比较器，如果fromKey不实现Comparable ）。如果fromKey无法与当前在地图中的键进行比较，则实施可能但不是必须抛出此异常。
    
    NullPointerException - 如果 fromKey为空
    
    IllegalArgumentException - 如果此地图本身具有有限的范围，并且 fromKey位于范围的范围之外
  - subMap
```
public ConcurrentNavigableMap<K,V> subMap(K fromKey,
                                          K toKey)
```
    说明从界面： NavigableMap复制
    
    返回此地图部分的视图，其关键字范围为fromKey （含），不toKey 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器不兼容（或者如果地图没有比较器，如果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器不兼容（或者如果地图没有比较器，如果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 。返回的条目不支持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空， null
  - pollLastEntry
```
public Map.Entry<K,V> pollLastEntry()
```
    删除并返回与该地图中最大键相关联的键值映射，如果地图为空，则返回null 。返回的条目不支持Entry.setValue方法。
    
    Specified by:
    
    pollLastEntry在界面 NavigableMap<K,V>
    
    结果
    
    删除该地图的最后一个条目，如果 null空， 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 - 应用于每个条目的功能

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class ConcurrentSkipListMap<K,V>

Nested Class Summary

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

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

构造方法摘要

方法摘要

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

构造方法详细信息

ConcurrentSkipListMap

ConcurrentSkipListMap

ConcurrentSkipListMap

ConcurrentSkipListMap

方法详细信息

clone

containsKey

get

getOrDefault

put

remove

containsValue

size

isEmpty

clear

computeIfAbsent

computeIfPresent

compute

merge

keySet

navigableKeySet

values

entrySet

descendingMap

descendingKeySet

equals

putIfAbsent

remove

replace

replace

comparator

firstKey

lastKey

subMap

headMap

tailMap

subMap

headMap

tailMap

lowerEntry

lowerKey

floorEntry

floorKey

ceilingEntry

ceilingKey

higherEntry

higherKey

firstEntry

lastEntry

pollFirstEntry

pollLastEntry

forEach

replaceAll