ConcurrentSkipListMap (Java Platform SE 8 )

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

参数类型

K -钥匙的Map保持型

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实施。Map是根据它的键的 natural ordering排序，或通过设置在Map创建时 Comparator，取决于使用哪个构造函数。
这个类实现SkipLists提供预期的平均日志并发变异（N）的时间成本的containsKey，get，put和remove操作及其变体。插入、移除、更新和访问操作同时安全地执行多个线程。

迭代器和spliterators是weakly consistent。

上行关键点的观点和他们的迭代器的快比降。

对所有Map.Entry返回这类及其观点方法代表快照映射在当时产生的。他们不支持Entry.setValue方法。（注意，可以在相关的Map使用put，改变映射putIfAbsent，或replace，取决于哪些你需要的效果。）

要小心的是，不像大多数集合的方法，size不是常量时间的操作。由于这些映射的异步性质，确定当前元素的数量需要一个元素的遍历，如果这个集合在遍历过程中被修改，那么可能会报告不准确的结果。此外，大容量操作putAll，equals，toArray，containsValue，和clear不保证是自动执行。例如，一个putAll并发运行的操作一个迭代器可能会认为只有一些加入的元素。

这个类和它的观点和迭代器实现所有的可选方法的Map和Iterator接口。像大多数其他并发集合，这类不允许null键或值的使用因为有些空返回值无法可靠区分元素的缺失。

这个班的一员 Java Collections Framework。

从以下版本开始：

一点六

另请参见：

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()` 构建了一个新的、空的Map，根据键的 natural ordering排序。
`ConcurrentSkipListMap(Comparator<? super K> comparator)` 构造一个新的，空的映射，根据指定的比较器进行排序。
`ConcurrentSkipListMap(Map<? extends K,? extends V> m)` 构建了一个新的Map包含相同的映射为给定的Map，根据键的 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`如果没有这样的关键。
`void`	`clear()` 从这个映射中移除所有的映射。
`ConcurrentSkipListMap<K,V>`	`clone()` 返回该 `ConcurrentSkipListMap`实例浅拷贝。
`Comparator<? super K>`	`comparator()` 返回用于秩序在这个Map钥匙的比较器，或 `null`如果这个Map使用其密钥的 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)` 如果指定的键是不是已经与一个值关联，试图使用给定的映射功能，进入到这个Map除非 `null`计算其价值。
`V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)` 如果指定键的值存在，则尝试计算给定键的一个新的映射和它当前的映射值。
`boolean`	`containsKey(Object key)` 返回 `true`如果这Map包含一个指定的键映射。
`boolean`	`containsValue(Object value)` 返回 `true`如果映射到指定的值的一个或多个键。
`NavigableSet<K>`	`descendingKeySet()` 返回一个相反的顺序 `NavigableSet`查看键包含在这个Map。
`ConcurrentNavigableMap<K,V>`	`descendingMap()` 返回此映射中包含的映射的逆顺序视图。
`Set<Map.Entry<K,V>>`	`entrySet()` 返回一个 `Set`映射的视图包含在这个Map。
`boolean`	`equals(Object o)` 将指定的对象与此映射的相等性进行比较。
`Map.Entry<K,V>`	`firstEntry()` 返回一个与该图的最小密钥相关的键值映射，或 `null`如果Map是空的。
`K`	`firstKey()` 返回当前在该Map中的第一个（最低）键。
`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`如果这个Map不包含的键映射。
`V`	`getOrDefault(Object key, V defaultValue)` 返回指定的键映射的值，或指定默认值如果这个Map不包含的键映射。
`ConcurrentNavigableMap<K,V>`	`headMap(K toKey)` 返回从这个Map的关键是严格小于 `toKey`部分。
`ConcurrentNavigableMap<K,V>`	`headMap(K toKey, boolean inclusive)` 返回从这个Map的关键是少部分（或相等，如果 `inclusive`是真的） `toKey`。
`Map.Entry<K,V>`	`higherEntry(K key)` 返回的键值映射与最关键严格大于给定的键，或 `null`如果没有这样的关键。
`K`	`higherKey(K key)` 返回最关键严格大于给定的键，或 `null`如果没有这样的关键。
`boolean`	`isEmpty()` 返回 `true`如果这个Map不包含键值的映射。
`NavigableSet<K>`	`keySet()` 返回一个 `NavigableSet`查看键包含在这个Map。
`Map.Entry<K,V>`	`lastEntry()` 返回一个与该Map的最大密钥相关的键值映射，或 `null`如果Map是空的。
`K`	`lastKey()` 返回当前在该Map中的最后（最高）键。
`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。
`Map.Entry<K,V>`	`pollFirstEntry()` 删除并返回一个与该图的最小密钥相关的键值映射，或 `null`如果Map是空的。
`Map.Entry<K,V>`	`pollLastEntry()` 删除并返回一个与该Map的最大密钥相关的键值映射，或 `null`如果Map是空的。
`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)` 返回从这个Map的键范围从 `fromKey`到 `toKey`部分。
`ConcurrentNavigableMap<K,V>`	`subMap(K fromKey, K toKey)` 返回从这个Map的键范围从 `fromKey`，包容的部分 `toKey`，独家。
`ConcurrentNavigableMap<K,V>`	`tailMap(K fromKey)` 返回从这个Map的关键是大于或等于 `fromKey`部分。
`ConcurrentNavigableMap<K,V>`	`tailMap(K fromKey, boolean inclusive)` 返回从这个Map的关键是大于（或等于部分，如果 `inclusive`是真的） `fromKey`。
`Collection<V>`	`values()` 返回一个 `Collection`视图的值包含在这个Map。

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

- Constructor Detail
  - ConcurrentSkipListMap
```
public ConcurrentSkipListMap()
```
    构建了一个新的、空的Map，根据键的 natural ordering排序。
  - ConcurrentSkipListMap
```
public ConcurrentSkipListMap(Comparator<? super K> comparator)
```
    构造一个新的，空的映射，根据指定的比较器进行排序。
    
    参数
    
    comparator -比较器将用于订购这张Map。如果 null，钥匙的 natural ordering将使用。
  - ConcurrentSkipListMap
```
public ConcurrentSkipListMap(Map<? extends K,? extends V> m)
```
    构建了一个新的Map包含相同的映射为给定的Map，根据键的 natural ordering排序。
    
    参数
    
    m的映射被放置在这个Map的Map
    
    异常
    
    如果在 m ClassCastException键并不 Comparable，或互不可比
    
    NullPointerException -如果指定Map或其任何键或值无效
  - ConcurrentSkipListMap
```
public ConcurrentSkipListMap(SortedMap<K,? extends V> m)
```
    构造一个包含相同映射的新映射，并使用指定的排序映射使用相同的排序。
    
    参数
    
    m -排序图的映射是放在这张Map上，和其比较器是用来解决这个Map
    
    异常
    
    NullPointerException -如果指定的排序图或其任何键或值无效
- 方法详细信息
  - clone
```
public ConcurrentSkipListMap<K,V> clone()
```
    返回该 ConcurrentSkipListMap实例浅拷贝。（键和值本身没有被克隆。）
    
    重写：
    
    clone 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    这张Map的浅本
    
    另请参见：
    
    Cloneable
  - containsKey
```
public boolean containsKey(Object key)
```
    返回 true如果这Map包含一个指定的键映射。
    
    Specified by:
    
    containsKey 接口 Map<K,V>
    
    重写：
    
    containsKey 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key键的存在，在这张Map上可以进行测试
    
    结果
    
    true如果这Map包含一个指定的键映射
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - get
```
public V get(Object key)
```
    返回指定的键映射的值，或 null如果这个Map不包含的键映射。
    更正式地说，如果这个图中包含了从关键k到价值v这样key比较等于k根据Map的排序，那么这个方法返回v；否则返回null。（最多可以有一个这样的映射。）
    
    Specified by:
    
    get 接口 Map<K,V>
    
    重写：
    
    get 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key -关键的相关值被返回
    
    结果
    
    值，指定的键映射，或 null如果这个Map不包含的键映射
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - getOrDefault
```
public V getOrDefault(Object key,
                      V defaultValue)
```
    返回指定的键映射的值，或指定默认值如果这个Map不包含的键映射。
    
    Specified by:
    
    getOrDefault 接口 ConcurrentMap<K,V>
    
    Specified by:
    
    getOrDefault 接口 Map<K,V>
    
    参数
    
    key的关键
    
    defaultValue -如果这Map没有包含给定的键映射返回的值
    
    结果
    
    的关键，如果目前的映射；其他的默认值
    
    异常
    
    NullPointerException -如果指定的键是空的
    
    从以下版本开始：
    
    一点八
  - put
```
public V put(K key,
             V value)
```
    将指定的值与此映射中的指定键关联。如果映射以前包含一个键的映射，旧值将被替换。
    
    Specified by:
    
    put 接口 Map<K,V>
    
    重写：
    
    put 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key键与指定的值是相关联的
    
    value值必须与指定键关联
    
    结果
    
    与指定的键相关联的前一个值，或 null如果没有键映射
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键或值为空
  - remove
```
public V remove(Object key)
```
    如果存在的话，从这个映射中移除指定的键的映射。
    
    Specified by:
    
    remove 接口 Map<K,V>
    
    重写：
    
    remove 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key键的映射应该被删除
    
    结果
    
    与指定的键相关联的前一个值，或 null如果没有键映射
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - containsValue
```
public boolean containsValue(Object value)
```
    返回 true如果映射到指定的值的一个或多个键。此操作需要在Map大小中的时间线性。此外，它是可能的Map在执行过程中的这种方法的变化，在这种情况下，返回的结果可能是不准确的。
    
    Specified by:
    
    containsValue 接口 Map<K,V>
    
    重写：
    
    containsValue 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    在这张Map上 value -它的存在价值进行测试
    
    结果
    
    true如果映射到 value存在； false否则
    
    异常
    
    NullPointerException -如果指定的值为空
  - size
```
public int size()
```
    返回这个映射中的键值映射的数目。如果这个Map包含多 Integer.MAX_VALUE元素，则返回 Integer.MAX_VALUE。
    请注意，与大多数集合不同，此方法不是一个常数时间操作。由于这些Map的异步性质，确定当前的元素的数量需要遍历他们所有来计算它们。此外，它是可能的大小在执行过程中的这种方法的变化，在这种情况下，返回的结果将是不准确的。因此，这种方法通常是不是非常有用的并发应用程序。
    
    Specified by:
    
    size 接口 Map<K,V>
    
    重写：
    
    size 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    这个Map中的元素的数量
  - isEmpty
```
public boolean isEmpty()
```
    返回 true如果这个Map不包含键值的映射。
    
    Specified by:
    
    isEmpty 接口 Map<K,V>
    
    重写：
    
    isEmpty 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    true如果这个Map不包含键值的映射
  - 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)
```
    如果指定的键是不是已经与一个值关联，试图使用给定的映射功能，进入到这个Map除非 null计算其价值。功能不一定适用于一次原子只有价值是不存在的。
    
    Specified by:
    
    computeIfAbsent 接口 ConcurrentMap<K,V>
    
    Specified by:
    
    computeIfAbsent 接口 Map<K,V>
    
    参数
    
    key键与指定的值是相关联的
    
    mappingFunction的函数来计算一个值
    
    结果
    
    如果计算的值为空，则与指定的键相关联的当前（现有的或计算的）值
    
    异常
    
    NullPointerException -如果指定的键是无效的或映射函数是空的
    
    从以下版本开始：
    
    一点八
  - 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的函数来计算一个值
    
    结果
    
    与指定的键相关联的新值，或为空
    
    异常
    
    NullPointerException -如果指定的键是无效的或remappingfunction是空的
    
    从以下版本开始：
    
    一点八
  - 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的函数来计算一个值
    
    结果
    
    与指定的键相关联的新值，或为空
    
    异常
    
    NullPointerException -如果指定的键是无效的或remappingfunction是空的
    
    从以下版本开始：
    
    一点八
  - 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 -函数重新计算值如果存在
    
    结果
    
    与指定的键相关联的新值，或为空
    
    异常
    
    NullPointerException -如果指定的键或值为空或remappingfunction是空的
    
    从以下版本开始：
    
    一点八
  - keySet
```
public NavigableSet<K> keySet()
```
    返回一个 NavigableSet的关键视图包含在这个Map。
    该集合的迭代器以提升顺序返回键。设定的spliterator另外报道Spliterator.CONCURRENT，Spliterator.NONNULL，Spliterator.SORTED和Spliterator.ORDERED，一遇到秩序，提升关键点。的spliterator的比较器（见Spliterator.getComparator()）是null如果Map的比较（见comparator()）是null。否则，该spliterator的比较器相同或施加相同的总排序为Map的比较。
    
    该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。设置支持元素的去除，从Map中移除相应的映射，通过Iterator.remove，Set.remove，removeAll，retainAll，和clear操作。它不支持add或addAll操作。
    
    视图的迭代器和spliterators是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>
    
    结果
    
    在这张Map上的键的可导航的集合视图
  - navigableKeySet
```
public NavigableSet<K> navigableKeySet()
```
    从接口复制的描述： ConcurrentNavigableMap
    
    返回一个 NavigableSet查看键包含在这个Map。该集合的迭代器以提升顺序返回键。该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。设置支持元素的去除，从Map中移除相应的映射，通过 Iterator.remove， Set.remove， removeAll， retainAll，和 clear操作。它不支持 add或 addAll操作。
    视图的迭代器和spliterators是weakly consistent。
    
    Specified by:
    
    navigableKeySet 接口 ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    navigableKeySet 接口 NavigableMap<K,V>
    
    结果
    
    在这张Map上的键的可导航的集合视图
  - values
```
public Collection<V> values()
```
    返回一个 Collection视图的值包含在这个Map。
    集合的迭代器返回相应键的上升顺序的值。集合的spliterator另外报道Spliterator.CONCURRENT，Spliterator.NONNULL和Spliterator.ORDERED，一遇到秩序，提升相应的按键顺序。
    
    集合是由Map支持的，所以对Map的变化反映在集合中，反之亦然。收集支持元素的去除，从Map中移除相应的映射，通过Iterator.remove，Collection.remove，removeAll，retainAll和clear操作。它不支持add或addAll操作。
    
    视图的迭代器和spliterators是weakly consistent。
    
    Specified by:
    
    values 接口 Map<K,V>
    
    Specified by:
    
    values 接口 SortedMap<K,V>
    
    重写：
    
    values 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    一个包含在这个Map中的值的集合视图
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    返回一个 Set视图的映射包含在这个Map。
    该集合的迭代器返回键顺序中的条目。设定的spliterator另外报道Spliterator.CONCURRENT，Spliterator.NONNULL，Spliterator.SORTED和Spliterator.ORDERED，一遇到秩序，提升关键点。
    
    该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。设置支持元素的去除，从Map中移除相应的映射，通过Iterator.remove，Set.remove，removeAll，retainAll和clear操作。它不支持add或addAll操作。
    
    视图的迭代器和spliterators是weakly consistent。
    
    的Map.Entry元素被iterator或spliterator不支持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
    
    返回此映射中包含的映射的逆顺序视图。该Map是由这张Map的支持，所以对Map的变化反映在Map上，反之亦然。
    返回Map具有订购相当于Collections.reverseOrder(comparator())。表达m.descendingMap().descendingMap()返回从m本质上相当于m。
    
    Specified by:
    
    descendingMap 接口 ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    descendingMap 接口 NavigableMap<K,V>
    
    结果
    
    这张Map的一个相反的顺序视图
  - descendingKeySet
```
public NavigableSet<K> descendingKeySet()
```
    从接口复制的描述： ConcurrentNavigableMap
    
    返回一个相反的顺序 NavigableSet查看键包含在这个Map。该集合的迭代器以递减的顺序返回键。该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。设置支持元素的去除，从Map中移除相应的映射，通过 Iterator.remove， Set.remove， removeAll， retainAll，和 clear操作。它不支持 add或 addAll操作。
    视图的迭代器和spliterators是weakly consistent。
    
    Specified by:
    
    descendingKeySet 接口 ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    descendingKeySet 接口 NavigableMap<K,V>
    
    结果
    
    在这张Map中的键的一个反向顺序可导航的集合视图
  - equals
```
public boolean equals(Object o)
```
    将指定的对象与此映射的相等性进行比较。返回 true如果给定的对象也是一个Map和两图表示相同的映射。更正式地说，两个Map m1和 m2表示相同的映射，如果 m1.entrySet().equals(m2.entrySet())。此操作可能如果Map同时修改该方法的执行过程中返回错误的结果。
    
    Specified by:
    
    equals 接口 Map<K,V>
    
    重写：
    
    equals 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    o对象进行比较，这张Map的平等
    
    结果
    
    true指定对象是否等于这个Map
    
    另请参见：
    
    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 -如果指定的键不能与目前在Map的按键相比
    
    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 -如果指定的键不能与目前在Map的按键相比
    
    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 -如果指定的键不能与目前在Map的按键相比
    
    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 -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键或值为空
  - comparator
```
public Comparator<? super K> comparator()
```
    从接口复制的描述： SortedMap
    
    返回用于秩序在这个Map钥匙的比较器，或 null如果这个Map使用其密钥的 natural ordering。
    
    Specified by:
    
    comparator 接口 SortedMap<K,V>
    
    结果
    
    比较器用以在这个Map的钥匙，或 null如果这个Map使用的键的自然顺序
  - firstKey
```
public K firstKey()
```
    从接口复制的描述： SortedMap
    
    返回当前在该Map中的第一个（最低）键。
    
    Specified by:
    
    firstKey 接口 SortedMap<K,V>
    
    结果
    
    在这个Map中的第一个（最低）键
    
    异常
    
    NoSuchElementException -如果这Map是空的
  - lastKey
```
public K lastKey()
```
    从接口复制的描述： SortedMap
    
    返回当前在该Map中的最后（最高）键。
    
    Specified by:
    
    lastKey 接口 SortedMap<K,V>
    
    结果
    
    在这个Map中的最后（最高）键
    
    异常
    
    NoSuchElementException -如果这Map是空的
  - subMap
```
public ConcurrentNavigableMap<K,V> subMap(K fromKey,
                                          boolean fromInclusive,
                                          K toKey,
                                          boolean toInclusive)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的键范围从 fromKey到 toKey部分。如果 fromKey和 toKey相等，返回Map是空的，除非 fromInclusive toInclusive都是真实的。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在它的范围之外的一个IllegalArgumentException，或构建一个区块是其端点超出其范围。
    
    Specified by:
    
    subMap 接口 ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    subMap 接口 NavigableMap<K,V>
    
    参数
    
    fromKey -返回Map的关键端点低
    
    fromInclusive - true如果低的终点是被包含在返回的视图
    
    toKey -返回Map的关键点
    
    toInclusive - true如果高终点是被包含在返回的视图
    
    结果
    
    看这张Map的键范围从 fromKey到 toKey部分
    
    异常
    
    ClassCastException -如果 fromKey和 toKey不能与另一个使用这个Map的比较器（或者，如果Map没有比较器，采用自然排序）。实现可能，但不是必需的，如果 fromKey或 toKey不能相比，目前在Map键抛出该异常。
    
    NullPointerException -如果 fromKey或 toKey是空的
    
    IllegalArgumentException -如果 fromKey大于 toKey；或者如果这Map本身有一个限制的范围内，和 fromKey或 toKey超出范围的界限
  - headMap
```
public ConcurrentNavigableMap<K,V> headMap(K toKey,
                                           boolean inclusive)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的关键是少部分（或相等，如果 inclusive是真的） toKey。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的IllegalArgumentException。
    
    Specified by:
    
    headMap 接口 ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    headMap 接口 NavigableMap<K,V>
    
    参数
    
    toKey -返回Map的关键点
    
    inclusive - true如果高终点是被包含在返回的视图
    
    结果
    
    看这张Map的关键是少部分（或相等，如果 inclusive是真的） toKey
    
    异常
    
    ClassCastException -如果 toKey不是这个Map的比较器兼容的（或者，如果Map没有比较，如果 toKey不实现 Comparable）。实现可能，但不是必需的，如果 toKey不能相比，目前在Map键抛出该异常。
    
    NullPointerException -如果 toKey是空的
    
    IllegalArgumentException -如果这Map本身有一个限制的范围内，和 toKey超出范围的界限
  - tailMap
```
public ConcurrentNavigableMap<K,V> tailMap(K fromKey,
                                           boolean inclusive)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的关键是大于（或等于部分，如果 inclusive是真的） fromKey。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的IllegalArgumentException。
    
    Specified by:
    
    tailMap 接口 ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    tailMap 接口 NavigableMap<K,V>
    
    参数
    
    fromKey -返回Map的关键端点低
    
    inclusive - true如果低的终点是被包含在返回的视图
    
    结果
    
    看这张Map的关键是大于（或等于部分，如果 inclusive是真的） fromKey
    
    异常
    
    ClassCastException -如果 fromKey不是这个Map的比较器兼容的（或者，如果Map没有比较，如果 fromKey不实现 Comparable）。实现可能，但不是必需的，如果 fromKey不能相比，目前在Map键抛出该异常。
    
    NullPointerException -如果 fromKey是空的
    
    IllegalArgumentException -如果这Map本身有一个限制的范围内，和 fromKey超出范围的界限
  - subMap
```
public ConcurrentNavigableMap<K,V> subMap(K fromKey,
                                          K toKey)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的键范围从 fromKey，包容的部分 toKey，独家。（如果 fromKey和 toKey相等，返回Map是空的。）返回的Map由Map的支持，所以在返回的Map变化都反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的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高端点（独家）返回的映射中的键
    
    结果
    
    看这张Map的键范围从 fromKey，包容的部分 toKey，独家
    
    异常
    
    ClassCastException -如果 fromKey和 toKey不能与另一个使用这个Map的比较器（或者，如果Map没有比较器，采用自然排序）。实现可能，但不是必需的，如果 fromKey或 toKey不能相比，目前在Map键抛出该异常。
    
    NullPointerException -如果 fromKey或 toKey是空的
    
    IllegalArgumentException -如果 fromKey大于 toKey；或者如果这Map本身有一个限制的范围内，和 fromKey或 toKey超出范围的界限
  - headMap
```
public ConcurrentNavigableMap<K,V> headMap(K toKey)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的关键是严格小于 toKey部分。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的IllegalArgumentException。
    
    相当于headMap(toKey, false)。
    
    Specified by:
    
    headMap 接口 ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    headMap 接口 NavigableMap<K,V>
    
    Specified by:
    
    headMap 接口 SortedMap<K,V>
    
    参数
    
    toKey高端点（独家）返回的映射中的键
    
    结果
    
    看这张Map的关键是严格小于 toKey部分
    
    异常
    
    ClassCastException -如果 toKey不是这个Map的比较器兼容的（或者，如果Map没有比较，如果 toKey不实现 Comparable）。实现可能，但不是必需的，如果 toKey不能相比，目前在Map键抛出该异常。
    
    NullPointerException -如果 toKey是空的
    
    IllegalArgumentException -如果这Map本身有一个限制的范围内，和 toKey超出范围的界限
  - tailMap
```
public ConcurrentNavigableMap<K,V> tailMap(K fromKey)
```
    从接口复制的描述： NavigableMap
    
    返回从这个Map的关键是大于或等于 fromKey部分。返回的Map是由这张Map的支持，所以在返回的Map的变化反映在这张Map上，反之亦然。返回的Map支持这张Map支持的所有可选的Map操作。
    返回的Map将把企图把钥匙插在其范围内的IllegalArgumentException。
    
    相当于tailMap(fromKey, true)。
    
    Specified by:
    
    tailMap 接口 ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    tailMap 接口 NavigableMap<K,V>
    
    Specified by:
    
    tailMap 接口 SortedMap<K,V>
    
    参数
    
    fromKey低端点（含）返回的映射中的键
    
    结果
    
    看这张Map的关键是大于或等于 fromKey部分
    
    异常
    
    ClassCastException -如果 fromKey不是这个Map的比较器兼容的（或者，如果Map没有比较，如果 fromKey不实现 Comparable）。实现可能，但不是必需的，如果 fromKey不能相比，目前在Map键抛出该异常。
    
    NullPointerException -如果 fromKey是空的
    
    IllegalArgumentException -如果这Map本身有一个限制的范围内，和 fromKey超出范围的界限
  - lowerEntry
```
public Map.Entry<K,V> lowerEntry(K key)
```
    返回的键值映射与最大的关键严格小于给定的键，或 null如果没有这样的关键。返回项不支持 Entry.setValue方法。
    
    Specified by:
    
    lowerEntry 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    一个最大的不足 key入境，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - lowerKey
```
public K lowerKey(K key)
```
    从接口复制的描述： NavigableMap
    
    返回最大关键严格小于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    lowerKey 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    最大的不足 key，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - floorEntry
```
public Map.Entry<K,V> floorEntry(K key)
```
    返回的键值映射与最大的小于或等于给定的键，或 null如果没有这样的关键。返回项不支持 Entry.setValue方法。
    
    Specified by:
    
    floorEntry 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    一个最关键的小于或等于 key入境，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - floorKey
```
public K floorKey(K key)
```
    从接口复制的描述： NavigableMap
    
    返回最大关键小于或等于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    floorKey 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    最关键的是小于或等于 key，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - ceilingEntry
```
public Map.Entry<K,V> ceilingEntry(K key)
```
    返回的键值映射与最关键的大于或等于给定的键，或 null如果没有这样的入口。返回项不支持 Entry.setValue方法。
    
    Specified by:
    
    ceilingEntry 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    一个大于或等于 key最关键的条目，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - ceilingKey
```
public K ceilingKey(K key)
```
    从接口复制的描述： NavigableMap
    
    最关键的收益大于或等于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    ceilingKey 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    大于或等于 key最关键，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - higherEntry
```
public Map.Entry<K,V> higherEntry(K key)
```
    返回的键值映射与最关键严格大于给定的键，或 null如果没有这样的关键。返回项不支持 Entry.setValue方法。
    
    Specified by:
    
    higherEntry 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    一个大于 key最关键的条目，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - higherKey
```
public K higherKey(K key)
```
    从接口复制的描述： NavigableMap
    
    返回最关键严格大于给定的键，或 null如果没有这样的关键。
    
    Specified by:
    
    higherKey 接口 NavigableMap<K,V>
    
    参数
    
    key的关键
    
    结果
    
    大于 key最关键，或 null如果没有这样的关键
    
    异常
    
    ClassCastException -如果指定的键不能与目前在Map的按键相比
    
    NullPointerException -如果指定的键是空的
  - firstEntry
```
public Map.Entry<K,V> firstEntry()
```
    返回一个与该图的最小密钥相关的键值映射，或 null如果Map是空的。返回项不支持 Entry.setValue方法。
    
    Specified by:
    
    firstEntry 接口 NavigableMap<K,V>
    
    结果
    
    一个用最少的按键输入，或 null如果这个Map是空的
  - lastEntry
```
public Map.Entry<K,V> lastEntry()
```
    返回一个与该Map的最大密钥相关的键值映射，或 null如果Map是空的。返回项不支持 Entry.setValue方法。
    
    Specified by:
    
    lastEntry 接口 NavigableMap<K,V>
    
    结果
    
    一个最关键的条目，或 null如果这个Map是空的
  - pollFirstEntry
```
public Map.Entry<K,V> pollFirstEntry()
```
    删除并返回一个与该图的最小密钥相关的键值映射，或 null如果Map是空的。返回项不支持 Entry.setValue方法。
    
    Specified by:
    
    pollFirstEntry 接口 NavigableMap<K,V>
    
    结果
    
    被删除的第一次进入这个Map，或 null如果这个Map是空的
  - pollLastEntry
```
public Map.Entry<K,V> pollLastEntry()
```
    删除并返回一个与该Map的最大密钥相关的键值映射，或 null如果Map是空的。返回项不支持 Entry.setValue方法。
    
    Specified by:
    
    pollLastEntry 接口 NavigableMap<K,V>
    
    结果
    
    删除这个Map上的入口，或 null如果这个Map是空的
  - 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

Constructor Detail

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