模块 java.base
包 java.util.concurrent

类 ConcurrentSkipListMap<K,V>

java.lang.Object
java.util.AbstractMap <K,V>
java.util.concurrent.ConcurrentSkipListMap<K,V>
类型参数：
K - 此map维护的键类型
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 实现。map根据其键的 自然排序 排序，或根据map创建时提供的 Comparator 排序，具体取决于使用的构造函数。

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

迭代器和拆分器是 弱一致 。

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

此类及其视图中的方法返回的所有 Map.Entry 对表示生成它们时映射的快照。他们 not 支持 Entry.setValue 方法。 （但是请注意，可以使用 put 、 putIfAbsent 或 replace 更改关联map中的映射，具体取决于您需要的效果。）

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

此类及其视图和迭代器实现了 Map 和 Iterator 接口的所有 optional 方法。与大多数其他并发集合一样，此类确实 not 允许使用 null 键或值，因为无法可靠地区分某些 null 返回值与元素的缺失。

此类是 Java 集合框架 的成员。

自从：
1.6
参见：

  • 构造方法详细信息

    • ConcurrentSkipListMap

      public ConcurrentSkipListMap()
      构造一个新的空映射，根据键的 自然排序 排序。

    • ConcurrentSkipListMap

      public ConcurrentSkipListMap(Comparator <? super K > comparator)
      构造一个新的空map，根据指定的比较器排序。
      参数：
      comparator - 将用于排序此map的比较器。如果 null ，将使用键的 自然排序。

    • ConcurrentSkipListMap

      public ConcurrentSkipListMap(Map <? extends K ,? extends V > m)
      构造一个包含与给定映射相同的映射的新映射，根据键的 自然排序 排序。
      参数：
      m - 其映射要放置在此map中的map
      抛出：
      ClassCastException - 如果 m 中的键不是 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的浅表副本
      参见：

    • containsKey

      public boolean containsKey(Object  key)
      如果此map包含指定键的映射，则返回 true。
      指定者：
      containsKey 在接口 Map<K,V> 中
      重写：
      containsKey 在类 AbstractMap<K,V> 中
      参数：
      key - 要测试其在此map中是否存在的键
      返回：
      true 如果此map包含指定键的映射
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • get

      public V  get(Object  key)
      返回指定键映射到的值，如果此map不包含键的映射，则返回 null。

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

      指定者：
      get 在接口 Map<K,V> 中
      重写：
      get 在类 AbstractMap<K,V> 中
      参数：
      key - 要返回其关联值的键
      返回：
      指定键映射到的值，如果此map不包含键的映射，则返回 null
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • getOrDefault

      public V  getOrDefault(Object  key, V  defaultValue)
      返回指定键映射到的值，如果此map不包含键的映射，则返回给定的 defaultValue。
      指定者：
      getOrDefault 在接口 ConcurrentMap<K,V> 中
      指定者：
      getOrDefault 在接口 Map<K,V> 中
      参数：
      key - 钥匙
      defaultValue - 如果此map不包含给定键的映射，则返回值
      返回：
      密钥的映射（如果存在）；否则默认值
      抛出：
      NullPointerException - 如果指定的键为空
      自从：
      1.8

    • put

      public V  put(K  key, V  value)
      将指定值与此map中的指定键相关联。如果map之前包含键的映射，则旧值将被替换。
      指定者：
      put 在接口 Map<K,V> 中
      重写：
      put 在类 AbstractMap<K,V> 中
      参数：
      key - 与指定值关联的键
      value - 与指定键关联的值
      返回：
      与指定键关联的先前值，或者 null 如果键没有映射
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键或值是 null

    • remove

      public V  remove(Object  key)
      从此map中删除指定键的映射（如果存在）。
      指定者：
      remove 在接口 Map<K,V> 中
      重写：
      remove 在类 AbstractMap<K,V> 中
      参数：
      key - 应删除映射的键
      返回：
      与指定键关联的先前值，或者 null 如果键没有映射
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • containsValue

      public boolean containsValue(Object  value)
      如果此map将一个或多个键映射到指定值，则返回 true。此操作需要与map大小成线性关系的时间。另外，在该方法执行过程中，map有可能发生变化，返回的结果可能不准确。
      指定者：
      containsValue 在接口 Map<K,V> 中
      重写：
      containsValue 在类 AbstractMap<K,V> 中
      参数：
      value - 要测试其在此map中是否存在的值
      返回：
      true 如果存在到 value 的映射； false否则
      抛出：
      NullPointerException - 如果指定值为空

    • size

      public int size()
      返回此map中键值映射的数量。如果map包含超过 Integer.MAX_VALUE 个元素，则返回 Integer.MAX_VALUE 。
      指定者：
      size 在接口 Map<K,V> 中
      重写：
      size 在类 AbstractMap<K,V> 中
      返回：
      此map中键值映射的数量

    • isEmpty

      public boolean isEmpty()
      如果此map不包含键值映射，则返回 true。
      指定者：
      isEmpty 在接口 Map<K,V> 中
      重写：
      isEmpty 在类 AbstractMap<K,V> 中
      返回：
      true 如果此map不包含键值映射

    • clear

      public void clear()
      从此map中删除所有映射。
      指定者：
      clear 在接口 Map<K,V> 中
      重写：
      clear 在类 AbstractMap<K,V> 中

    • computeIfAbsent

      public V  computeIfAbsent(K  key, Function <? super K ,? extends V > mappingFunction)
      如果指定的键尚未与值关联，则尝试使用给定的映射函数计算其值并将其输入到此map中，除非 null 。该函数NOT保证仅在值不存在时以原子方式应用一次。
      指定者：
      computeIfAbsent 在接口 ConcurrentMap<K,V> 中
      指定者：
      computeIfAbsent 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      mappingFunction - 计算值的函数
      返回：
      与指定键关联的当前（现有或计算）值，如果计算值为 null，则为 null
      抛出：
      NullPointerException - 如果指定键为空或 mappingFunction 为空
      自从：
      1.8

    • computeIfPresent

      public V  computeIfPresent(K  key, BiFunction <? super K ,? super V ,? extends V > remappingFunction)
      如果存在指定键的值，则尝试在给定键及其当前映射值的情况下计算新映射。该函数NOT保证以原子方式应用一次。
      指定者：
      computeIfPresent 在接口 ConcurrentMap<K,V> 中
      指定者：
      computeIfPresent 在接口 Map<K,V> 中
      参数：
      key - 值可能关联的键
      remappingFunction - 计算值的函数
      返回：
      与指定键关联的新值，如果没有则为 null
      抛出：
      NullPointerException - 如果指定键为空或 remappingFunction 为空
      自从：
      1.8

    • compute

      public V  compute(K  key, BiFunction <? super K ,? super V ,? extends V > remappingFunction)
      尝试计算指定键及其当前映射值的映射（如果没有当前映射，则为 null）。该函数NOT保证以原子方式应用一次。
      指定者：
      compute 在接口 ConcurrentMap<K,V> 中
      指定者：
      compute 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      remappingFunction - 计算值的函数
      返回：
      与指定键关联的新值，如果没有则为 null
      抛出：
      NullPointerException - 如果指定键为空或 remappingFunction 为空
      自从：
      1.8

    • merge

      public V  merge(K  key, V  value, BiFunction <? super V ,? super V ,? extends V > remappingFunction)
      如果指定的键尚未与值关联，则将其与给定值关联。否则，用给定重映射函数的结果替换该值，或者删除 if null 。该函数NOT保证以原子方式应用一次。
      指定者：
      merge 在接口 ConcurrentMap<K,V> 中
      指定者：
      merge 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      value - 如果不存在则使用的值
      remappingFunction - 重新计算值的函数（如果存在）
      返回：
      与指定键关联的新值，如果没有则为 null
      抛出：
      NullPointerException - 如果指定的键或值是 null 或者 remappingFunction 是 null
      自从：
      1.8

    • keySet

      public NavigableSet <K > keySet()
      返回此map中包含的键的 NavigableSet 视图。

      该集合的迭代器按升序返回键。该集合的拆分器还报告 Spliterator.CONCURRENT 、 Spliterator.NONNULL 、 Spliterator.SORTED 和 Spliterator.ORDERED ，遇到顺序为升序键顺序。

      如果 map比较器 是 null，则 分离器的比较器 是 null。否则，拆分器的比较器与map的比较器相同或强加相同的总排序。

      该集合由map支持，因此对map的更改会反映在集合中，反之亦然。该集合支持元素删除，即通过 Iterator.remove 、 Set.remove 、 removeAll 、 retainAll 和 clear 操作从map中删除相应的映射。它不支持 add 或 addAll 操作。

      视图的迭代器和拆分器是 弱一致 。

      此方法等同于方法 navigableKeySet 。

      指定者：
      keySet 在接口 ConcurrentNavigableMap<K,V> 中
      指定者：
      keySet 在接口 Map<K,V> 中
      指定者：
      keySet 在接口 SortedMap<K,V> 中
      重写：
      keySet 在类 AbstractMap<K,V> 中
      返回：
      此map中键的可导航集合视图

    • values

      public Collection <V > values()
      返回此map中包含的值的 Collection 视图。

      集合的迭代器按相应键的升序返回值。集合的拆分器还报告 Spliterator.CONCURRENT 、 Spliterator.NONNULL 和 Spliterator.ORDERED ，遇到顺序是相应键的升序。

      集合由map支持，因此对map的更改会反映在集合中，反之亦然。该集合支持元素删除，即通过 Iterator.remove 、 Collection.remove 、 removeAll 、 retainAll 和 clear 操作从map中删除相应的映射。它不支持 add 或 addAll 操作。

      视图的迭代器和拆分器是 弱一致 。

      指定者：
      values 在接口 Map<K,V> 中
      指定者：
      values 在接口 SortedMap<K,V> 中
      重写：
      values 在类 AbstractMap<K,V> 中
      返回：
      此map中包含的值的集合视图

    • entrySet

      public Set <Map.Entry <K ,V >> entrySet()
      返回此map中包含的映射的 Set 视图。

      该集合的迭代器以升序键顺序返回条目。该集合的拆分器还报告 Spliterator.CONCURRENT 、 Spliterator.NONNULL 、 Spliterator.SORTED 和 Spliterator.ORDERED ，遇到顺序为升序键顺序。

      该集合由map支持，因此对map的更改会反映在集合中，反之亦然。该集合支持元素移除，即通过 Iterator.remove 、 Set.remove 、 removeAll 、 retainAll 和 clear 操作从map中移除相应的映射。它不支持 add 或 addAll 操作。

      视图的迭代器和拆分器是 弱一致 。

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

      指定者：
      entrySet 在接口 Map<K,V> 中
      指定者：
      entrySet 在接口 SortedMap<K,V> 中
      返回：
      此map中包含的映射的集合视图，按键升序排序

    • descendingMap

      public ConcurrentNavigableMap <K ,V > descendingMap()
      从接口 ConcurrentNavigableMap 复制的描述
      返回此map中包含的映射的逆序视图。降序图受此map支持，因此对map的更改会反映在降序图中，反之亦然。

      返回的map的排序等同于 Collections.reverseOrder (comparator()) 。表达式 m.descendingMap().descendingMap() 返回 m 的视图，本质上等同于 m 。

      指定者：
      descendingMap 在接口 ConcurrentNavigableMap<K,V> 中
      指定者：
      descendingMap 在接口 NavigableMap<K,V> 中
      返回：
      这张map的倒序视图

    • descendingKeySet

      public NavigableSet <K > descendingKeySet()
      从接口 ConcurrentNavigableMap 复制的描述
      返回此map中包含的键的逆序 NavigableSet 视图。该集合的迭代器按降序返回键。该集合由map支持，因此对map的更改会反映在集合中，反之亦然。该集合支持元素删除，即通过 Iterator.remove 、 Set.remove 、 removeAll 、 retainAll 和 clear 操作从map中删除相应的映射。它不支持 add 或 addAll 操作。

      视图的迭代器和拆分器是 弱一致 。

      指定者：
      descendingKeySet 在接口 ConcurrentNavigableMap<K,V> 中
      指定者：
      descendingKeySet 在接口 NavigableMap<K,V> 中
      返回：
      此map中键的逆序可导航集视图

    • equals

      public boolean equals(Object  o)
      比较指定对象与此map是否相等。如果给定对象也是一个映射并且两个映射表示相同的映射，则返回 true。更正式地说，两个映射 m1 和 m2 表示相同的映射，如果 m1.entrySet().equals(m2.entrySet()) 。如果在执行此方法期间同时修改了任一映射，则此操作可能会返回误导性结果。
      指定者：
      equals 在接口 Map<K,V> 中
      重写：
      equals 在类 AbstractMap<K,V> 中
      参数：
      o - 要与此map进行相等比较的对象
      返回：
      true 如果指定的对象等于这个map
      参见：

    • putIfAbsent

      public V  putIfAbsent(K  key, V  value)
      如果指定的键尚未与值关联，则将其与给定值关联。这相当于，对于这个 map : 
       
 if (!map.containsKey(key))
  return map.put(key, value);
 else
  return map.get(key);
      除了动作是原子执行的。
      指定者：
      putIfAbsent 在接口 ConcurrentMap<K,V> 中
      指定者：
      putIfAbsent 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      value - 与指定键关联的值
      返回：
      与指定键关联的先前值，或者 null 如果键没有映射
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键或值是 null

    • 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;
 }
      除了动作是原子执行的。
      指定者：
      remove 在接口 ConcurrentMap<K,V> 中
      指定者：
      remove 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      value - 预期与指定键关联的值
      返回：
      true 如果值被删除
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      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;
 }
      这等同于该操作是原子执行的。
      指定者：
      replace 在接口 ConcurrentMap<K,V> 中
      指定者：
      replace 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      oldValue - 预期与指定键关联的值
      newValue - 与指定键关联的值
      返回：
      true 如果值被替换
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果任何参数为空

    • replace

      public V  replace(K  key, V  value)
      仅当当前映射到某个值时才替换键的条目。这相当于，对于这个 map : 
       
 if (map.containsKey(key))
  return map.put(key, value);
 else
  return null;
      除了动作是原子执行的。
      指定者：
      replace 在接口 ConcurrentMap<K,V> 中
      指定者：
      replace 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      value - 与指定键关联的值
      返回：
      与指定键关联的先前值，或者 null 如果键没有映射
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键或值是 null

    • comparator

      public Comparator <? super K > comparator()
      从接口 SortedMap 复制的描述
      返回用于排序此map中的键的比较器，如果此map使用其键的自然排序，则返回null。
      指定者：
      comparator 在接口 SortedMap<K,V> 中
      返回：
      用于排序此map中的键的比较器，或者 null 如果此map使用其键的自然排序

    • firstKey

      public K  firstKey()
      从接口 SortedMap 复制的描述
      返回当前map中的第一个（最低）键。
      指定者：
      firstKey 在接口 SortedMap<K,V> 中
      返回：
      此map中当前的第一个（最低）键
      抛出：
      NoSuchElementException - 如果这张map是空的

    • lastKey

      public K  lastKey()
      从接口 SortedMap 复制的描述
      返回当前在此map中的最后一个（最高）键。
      指定者：
      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 相等，则返回的映射为空，除非 fromInclusive 和 toInclusive 都为真。返回的map受此map支持，因此返回map中的更改会反映在此map中，反之亦然。返回的map支持此map支持的所有可选map操作。

      返回的映射将抛出 IllegalArgumentException 尝试插入其范围之外的键，或构建其端点位于其范围之外的子图。

      指定者：
      subMap 在接口 ConcurrentNavigableMap<K,V> 中
      指定者：
      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操作。

      返回的映射将在尝试插入其范围之外的键时抛出 IllegalArgumentException。

      指定者：
      headMap 在接口 ConcurrentNavigableMap<K,V> 中
      指定者：
      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操作。

      返回的映射将在尝试插入其范围之外的键时抛出 IllegalArgumentException。

      指定者：
      tailMap 在接口 ConcurrentNavigableMap<K,V> 中
      指定者：
      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操作。

      返回的映射将在尝试插入其范围之外的键时抛出 IllegalArgumentException。

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

      指定者：
      subMap 在接口 ConcurrentNavigableMap<K,V> 中
      指定者：
      subMap 在接口 NavigableMap<K,V> 中
      指定者：
      subMap 在接口 SortedMap<K,V> 中
      参数：
      fromKey - 返回map中键的低端点（包括）
      toKey - 返回map中键的高端点（不包括）
      返回：
      此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操作。

      返回的映射将在尝试插入其范围之外的键时抛出 IllegalArgumentException。

      相当于 headMap(toKey, false) 。

      指定者：
      headMap 在接口 ConcurrentNavigableMap<K,V> 中
      指定者：
      headMap 在接口 NavigableMap<K,V> 中
      指定者：
      headMap 在接口 SortedMap<K,V> 中
      参数：
      toKey - 返回map中键的高端点（不包括）
      返回：
      此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操作。

      返回的映射将在尝试插入其范围之外的键时抛出 IllegalArgumentException。

      相当于 tailMap(fromKey, true) 。

      指定者：
      tailMap 在接口 ConcurrentNavigableMap<K,V> 中
      指定者：
      tailMap 在接口 NavigableMap<K,V> 中
      指定者：
      tailMap 在接口 SortedMap<K,V> 中
      参数：
      fromKey - 返回map中键的低端点（包括）
      返回：
      此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。返回的条目确实 not 支持 Entry.setValue 方法。
      指定者：
      lowerEntry 在接口 NavigableMap<K,V> 中
      参数：
      key - 钥匙
      返回：
      最大键小于 key 的条目，如果没有这样的键，则为 null
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • lowerKey

      public K  lowerKey(K  key)
      从接口 NavigableMap 复制的描述
      返回严格小于给定键的最大键，如果没有这样的键，则返回 null。
      指定者：
      lowerKey 在接口 NavigableMap<K,V> 中
      参数：
      key - 钥匙
      返回：
      小于 key 的最大密钥，如果没有这样的密钥，则为 null
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • floorEntry

      public Map.Entry <K ,V > floorEntry(K  key)
      返回与小于或等于给定键的最大键关联的键值映射，如果没有这样的键，则返回 null。返回的条目确实 not 支持 Entry.setValue 方法。
      指定者：
      floorEntry 在接口 NavigableMap<K,V> 中
      参数：
      key - 钥匙
      返回：
      最大键小于或等于 key 的条目，如果没有这样的键，则为 null
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • floorKey

      public K  floorKey(K  key)
      从接口 NavigableMap 复制的描述
      返回小于或等于给定键的最大键，如果没有这样的键，则返回 null。
      指定者：
      floorKey 在接口 NavigableMap<K,V> 中
      参数：
      key - 钥匙
      返回：
      小于或等于 key 的最大键，如果没有这样的键，则为 null
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • ceilingEntry

      public Map.Entry <K ,V > ceilingEntry(K  key)
      返回与大于或等于给定键的最小键关联的键值映射，如果没有这样的条目，则返回 null。返回的条目确实 not 支持 Entry.setValue 方法。
      指定者：
      ceilingEntry 在接口 NavigableMap<K,V> 中
      参数：
      key - 钥匙
      返回：
      最小键大于或等于 key 的条目，如果没有这样的键，则为 null
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • ceilingKey

      public K  ceilingKey(K  key)
      从接口 NavigableMap 复制的描述
      返回大于或等于给定键的最小键，如果没有这样的键，则返回 null。
      指定者：
      ceilingKey 在接口 NavigableMap<K,V> 中
      参数：
      key - 钥匙
      返回：
      大于或等于 key 的最小键，如果没有这样的键，则为 null
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • higherEntry

      public Map.Entry <K ,V > higherEntry(K  key)
      返回与严格大于给定键的最小键关联的键值映射，如果没有这样的键，则返回 null。返回的条目确实 not 支持 Entry.setValue 方法。
      指定者：
      higherEntry 在接口 NavigableMap<K,V> 中
      参数：
      key - 钥匙
      返回：
      最小键大于 key 的条目，如果没有这样的键，则为 null
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • higherKey

      public K  higherKey(K  key)
      从接口 NavigableMap 复制的描述
      返回严格大于给定键的最小键，如果没有这样的键，则返回 null。
      指定者：
      higherKey 在接口 NavigableMap<K,V> 中
      参数：
      key - 钥匙
      返回：
      大于 key 的最小键，或者 null 如果没有这样的键
      抛出：
      ClassCastException - 如果无法将指定键与当前map中的键进行比较
      NullPointerException - 如果指定的键为空

    • firstEntry

      public Map.Entry <K ,V > firstEntry()
      返回与此map中最少键关联的键值映射，如果map为空，则返回 null。返回的条目确实 not 支持 Entry.setValue 方法。
      指定者：
      firstEntry 在接口 NavigableMap<K,V> 中
      返回：
      具有最少键的条目，如果此map为空，则为 null

    • lastEntry

      public Map.Entry <K ,V > lastEntry()
      返回与此map中最大键关联的键值映射，如果map为空，则返回 null。返回的条目确实 not 支持 Entry.setValue 方法。
      指定者：
      lastEntry 在接口 NavigableMap<K,V> 中
      返回：
      具有最大键的条目，如果此map为空，则为 null

    • pollFirstEntry

      public Map.Entry <K ,V > pollFirstEntry()
      删除并返回与此map中最小键关联的键值映射，如果map为空，则返回 null。返回的条目确实 not 支持 Entry.setValue 方法。
      指定者：
      pollFirstEntry 在接口 NavigableMap<K,V> 中
      返回：
      此map的已删除第一个条目，如果此map为空，则为 null

    • pollLastEntry

      public Map.Entry <K ,V > pollLastEntry()
      删除并返回与此map中最大键关联的键值映射，如果map为空，则返回 null。返回的条目确实 not 支持 Entry.setValue 方法。
      指定者：
      pollLastEntry 在接口 NavigableMap<K,V> 中
      返回：
      此map的已删除最后一个条目，如果此map为空，则为 null