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实现。该地图是根据排序natural ordering其密钥，或通过Comparator在地图创建时提供，这取决于所使用的构造方法。
这个类实现的并发变种SkipLists提供预期平均log（n）的时间成本，为containsKey ， get ， put和remove操作及其变体。插入，删除，更新和访问操作由多个线程安全地同时执行。

迭代器和分裂器是weakly consistent 。

升序键有序视图及其迭代器比降序视图快。

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

要注意的是批量操作putAll ， equals ， toArray ， containsValue ，和clear 不能保证以原子方式执行的。例如，与putAll操作同时运行的迭代器可能只查看一些添加的元素。

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

此类是Java Collections Framework的成员。

从以下版本开始：

1.6

另请参见：

Serialized Form

嵌套类汇总
- 嵌套类/接口声明在类 java.util.AbstractMap
  AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>
- Nested classes/interfaces declared in interface java.util.Map
  Map.Entry<K,V>

构造方法摘要

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

方法摘要

所有方法实例方法具体的方法
变量和类型	方法	描述
`Map.Entry<K,V>`	`ceilingEntry(K key)`	返回与大于或等于给定键的最小键关联的键 - 值映射，如果没有此类条目，则 `null` 。
`K`	`ceilingKey(K key)`	返回大于或等于给定键的 `null`键，如果没有这样的键，则 `null` 。
`void`	`clear()`	从此映射中删除所有映射。
`ConcurrentSkipListMap<K,V>`	`clone()`	返回此 `ConcurrentSkipListMap`实例的浅表副本。
`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` 。
`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` 。
`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` 。
`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)`	如果指定的键尚未与值关联，请将其与给定值相关联。
`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)`	仅当前映射到给定值时才替换键的条目。
`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`视图。

声明方法的类 java.util.AbstractMap
hashCode, isEmpty, putAll, size, toString

声明方法的类 java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

声明方法的接口 java.util.concurrent.ConcurrentMap
forEach, replaceAll

声明方法的接口 java.util.concurrent.ConcurrentNavigableMap
descendingKeySet, descendingMap, navigableKeySet

声明方法的接口 java.util.Map
hashCode, isEmpty, putAll, size

声明方法的接口 java.util.SortedMap
comparator

- 构造方法详细信息
  - 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 - m映射放在此映射中的映射
    
    异常
    
    ClassCastException - 如果m中的密钥不是Comparable ，或者不可相互比较
    
    NullPointerException - 如果指定的映射或其任何键或值为null
  - ConcurrentSkipListMap
```
public ConcurrentSkipListMap(SortedMap<K,? extends V> m)
```
    构造一个包含相同映射的新映射，并使用与指定有序映射相同的顺序。
    
    参数
    
    m - 已映射的映射，其映射将放置在此映射中，其比较器将用于对此映射进行排序
    
    异常
    
    NullPointerException - 如果指定的有序映射或其任何键或值为null
- 方法详细信息
  - 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 - 如果指定的键或值为null
  - 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
  - clear
```
public void clear()
```
    从此映射中删除所有映射。
    
    Specified by:
    
    clear in interface 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，则为null
    
    异常
    
    NullPointerException - 如果指定的键为null或者mappingFunction为null
    
    从以下版本开始：
    
    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为null
    
    从以下版本开始：
    
    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或者 NullPointerException为null
    
    从以下版本开始：
    
    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 - 如果指定的键或值为null或者 NullPointerException为null
    
    从以下版本开始：
    
    1.8
  - keySet
```
public NavigableSet<K> keySet()
```
    返回此映射中包含的键的NavigableSet视图。
    set的迭代器按升序返回键。该集的spliterator另外报告Spliterator.CONCURRENT ， Spliterator.NONNULL ， Spliterator.SORTED和Spliterator.ORDERED ，与被按键的升序的顺序相遇。
    
    如果map's comparator是null则spliterator's 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 in interface SortedMap<K,V>
    
    重写：
    
    keySet在类 AbstractMap<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 in interface Map<K,V>
    
    Specified by:
    
    values ，界面 SortedMap<K,V>
    
    重写：
    
    values在类 AbstractMap<K,V>
    
    结果
    
    此映射中包含的值的集合视图
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    返回此映射中包含的映射的Set视图。
    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 in interface SortedMap<K,V>
    
    结果
    
    此映射中包含的映射的set视图，按升序键顺序排序
  - equals
```
public boolean equals(Object o)
```
    将指定对象与此映射进行比较以获得相等性。如果给定对象也是一个映射，并且两个映射表示相同的映射，则返回true 。更正式地说，如果m1.entrySet().equals(m2.entrySet()) ，则两个映射m1和m2表示相同的映射。如果在执行此方法期间同时修改了任一映射，则此操作可能会返回误导性结果。
    
    Specified by:
    
    equals in interface Map<K,V>
    
    重写：
    
    equals类 AbstractMap<K,V>
    
    参数
    
    o - 要与此映射进行相等性比较的对象
    
    结果
    
    true如果指定的对象等于此映射
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    如果指定的键尚未与值关联，请将其与给定值相关联。对于这个map ，这map ：
    if (!map.containsKey(key)) return map.put(key, value); else return map.get(key);
    除了动作以原子方式执行。
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface Map<K,V>
    
    参数
    
    key - 与指定值关联的键
    
    value - 与指定键关联的值
    
    结果
    
    与指定键关联的先前值，如果没有键的映射， null
    
    异常
    
    ClassCastException - 如果指定的键无法与地图中当前的键进行比较
    
    NullPointerException - 如果指定的键或值为null
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    仅当前映射到给定值时才删除键的条目。对于这个map ，这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 ，这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 - 如果任何参数为null
  - replace
```
public V replace(K key,
                 V value)
```
    仅当前映射到某个值时才替换键的条目。对于这个map ，这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 - 如果指定的键或值为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为空
    
    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如果 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 ）到toKey （独占）。（如果fromKey和toKey相等，则返回的地图为空。）返回的地图由此地图支持，因此返回的地图中的更改将反映在此地图中，反之亦然。返回的地图支持此地图支持的所有可选地图操作。
    返回的地图将尝试在其范围之外插入一个键时抛出IllegalArgumentException 。
    
    相当于subMap(fromKey, true, toKey, false) 。
    
    Specified by:
    
    subMap在界面 ConcurrentNavigableMap<K,V>
    
    Specified by:
    
    subMap in interface 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 in interface 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 in interface 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 in interface 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

Class ConcurrentSkipListMap<K,​V>

嵌套类汇总

嵌套类/接口声明在类 java.util.AbstractMap

Nested classes/interfaces declared in interface java.util.Map

构造方法摘要

方法摘要

声明方法的类 java.util.AbstractMap

声明方法的类 java.lang.Object

声明方法的接口 java.util.concurrent.ConcurrentMap

声明方法的接口 java.util.concurrent.ConcurrentNavigableMap

声明方法的接口 java.util.Map

声明方法的接口 java.util.SortedMap

构造方法详细信息

ConcurrentSkipListMap

ConcurrentSkipListMap

ConcurrentSkipListMap

ConcurrentSkipListMap

方法详细信息

clone

containsKey

get

getOrDefault

put

remove

containsValue

clear

computeIfAbsent

computeIfPresent

compute

merge

keySet

values

entrySet

equals

putIfAbsent

remove

replace

replace

firstKey

lastKey

subMap

headMap

tailMap

subMap

headMap

tailMap

lowerEntry

lowerKey

floorEntry

floorKey

ceilingEntry

ceilingKey

higherEntry

higherKey

firstEntry

lastEntry

pollFirstEntry

pollLastEntry

Class ConcurrentSkipListMap<K,V>