Module java.base
Package java.util.concurrent

Class ConcurrentSkipListMap<K,V>

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>, SequencedMap<K,V>, SortedMap<K,V>
public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V> implements ConcurrentNavigableMap<K,V>, Cloneable, Serializable
一个可扩展的并发ConcurrentNavigableMap实现。该映射根据其键的自然顺序或在创建映射时提供的Comparator进行排序，具体取决于使用哪个构造函数。

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

迭代器和分割器是弱一致的。

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

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

请注意，批量操作putAll、equals、toArray、containsValue和clear不能保证原子执行。例如，与putAll操作并发操作的迭代器可能只查看一些已添加的元素。

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

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

自版本:
1.6
参见:

  • Constructor Details

    • ConcurrentSkipListMap

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

    • ConcurrentSkipListMap

      public ConcurrentSkipListMap(Comparator<? super K> comparator)
      构造一个新的空映射，根据指定的比较器进行排序。
      参数:
      comparator - 将用于对此映射进行排序的比较器。如果为null，则将使用键的自然顺序。

    • ConcurrentSkipListMap

      public ConcurrentSkipListMap(Map<? extends K,? extends V> m)
      构造一个包含与给定映射相同映射的新映射，根据键的自然顺序进行排序。
      参数:
      m - 要放入此映射中的映射的地图
      抛出:
      ClassCastException - 如果m中的键不是Comparable，或者不是相互可比较的
      NullPointerException - 如果指定的地图或其任何键或值为null

    • ConcurrentSkipListMap

      public ConcurrentSkipListMap(SortedMap<K,? extends V> m)
      构造一个包含与指定排序映射相同映射并使用相同排序的新映射。
      参数:
      m - 要放入此映射中的排序映射，其比较器将用于对此映射进行排序
      抛出:
      NullPointerException - 如果指定的排序映射或其任何键或值为null

  • Method Details

    • clone

      public ConcurrentSkipListMap<K,V> clone()
      返回此ConcurrentSkipListMap实例的浅拷贝。(键和值本身不会被克隆。)
      覆盖:
      clone 在类 AbstractMap<K,V>
      返回:
      此映射的浅拷贝
      参见:

    • containsKey

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

    • get

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

      更正式地说，如果此映射包含从键k到值v的映射，使得根据映射的排序key等于k，则此方法返回v；否则返回null。(最多只能有一个这样的映射。)

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

    • getOrDefault

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

    • put

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

    • remove

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

    • containsValue

      public boolean containsValue(Object value)
      如果此映射将一个或多个键映射到指定值，则返回true。此操作所需时间与映射大小成线性关系。此外，在执行此方法期间，映射可能会发生更改，此时返回的结果可能不准确。
      指定者:
      containsValue 在接口 Map<K,V>中
      覆盖:
      containsValue 在类 AbstractMap<K,V>中
      参数:
      value - 要测试其在此映射中是否存在的值
      返回值:
      如果存在到value的映射，则返回true; 否则返回false
      抛出:
      NullPointerException - 如果指定的值为null

    • size

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

    • isEmpty

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

    • clear

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

    • computeIfAbsent

      public V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
      如果指定的键尚未与值关联，则尝试使用给定的映射函数计算其值并将其输入到此映射中，除非为null。如果值不存在，则不保证仅原子地应用函数一次。
      指定者:
      computeIfAbsent 在接口 ConcurrentMap<K,V>中
      指定者:
      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)
      如果指定键的值存在，则尝试根据键及其当前映射的值计算新映射。不保证仅原子地应用函数。
      指定者:
      computeIfPresent 在接口 ConcurrentMap<K,V>中
      指定者:
      computeIfPresent 在接口 Map<K,V>中
      参数:
      key - 可能与值关联的键
      remappingFunction - 用于计算值的函数
      返回值:
      与指定键关联的新值，如果没有则返回null
      抛出:
      NullPointerException - 如果指定的键为null或remappingFunction为null
      自:
      1.8

    • compute

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

    • merge

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

    • keySet

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

      集合的迭代器按升序返回键。集合的分割器另外报告Spliterator.CONCURRENT、Spliterator.NONNULL、Spliterator.SORTED和Spliterator.ORDERED，具有升序键顺序的相遇顺序。

      如果映射的比较器为null，则集合的迭代器的比较器为null。否则，集合的迭代器的比较器与映射的比较器相同或施加相同的完全排序。

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

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

      此方法等效于方法navigableKeySet。

      指定者：
      keySet 在接口 ConcurrentNavigableMap<K,V>
      指定者：
      keySet 在接口 Map<K,V>
      指定者：
      keySet 在接口 SortedMap<K,V>
      覆盖：
      keySet 在类 AbstractMap<K,V>
      返回：
      此映射中键的可导航集视图

    • values

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

      集合的迭代器按相应键的升序返回值。集合的分割器另外报告Spliterator.CONCURRENT、Spliterator.NONNULL和Spliterator.ORDERED，具有相应键的升序相遇顺序。

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

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

      指定者：
      values 在接口 Map<K,V>
      指定者：
      values 在接口 SortedMap<K,V>
      覆盖：
      values 在类 AbstractMap<K,V>
      返回：
      此映射中值的集合视图

    • entrySet

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

      集合的迭代器按升序键顺序返回条目。集合的分割器另外报告Spliterator.CONCURRENT、Spliterator.NONNULL、Spliterator.SORTED和Spliterator.ORDERED，具有升序键顺序的相遇顺序。

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

      视图的迭代器和分割器遍历的iterator或spliterator不支持setValue操作。

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

    • descendingMap

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

      返回的映射具有等效于Collections.reverseOrder(comparator())的排序。表达式m.descendingMap().descendingMap()返回与m本质上等效的m视图。

      指定者：
      descendingMap 在接口 ConcurrentNavigableMap<K,V>
      指定者：
      descendingMap 在接口 NavigableMap<K,V>
      返回：
      此映射的逆序视图

    • descendingKeySet

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

      该视图的迭代器和分割器是弱一致性的。

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

    • equals

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

    • 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 - 如果指定键无法与映射中当前的键进行比较
      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 - 如果指定键无法与映射中当前的键进行比较
      NullPointerException - 如果指定键为null

    • 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 - 如果指定键无法与映射中当前的键进行比较
      NullPointerException - 如果任何参数为null

    • 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 - 如果指定键无法与映射中当前的键进行比较
      NullPointerException - 如果指定键或值为null

    • comparator

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

    • firstKey

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

    • lastKey

      public K lastKey()
      从接口复制的描述： SortedMap
      返回此映射中当前的最后一个（最高）键。
      指定由：
      lastKey 在接口 SortedMap<K,V>
      返回：
      此映射中当前的最后一个（最高）键
      抛出：
      NoSuchElementException - 如果此映射为空

    • putFirst

      public V putFirst(K k, V v)
      抛出UnsupportedOperationException。此映射的比较方法引起的遇到顺序决定了映射的位置，因此不支持显式定位。
      指定由：
      putFirst 在接口 SequencedMap<K,V>
      指定由：
      putFirst 在接口 SortedMap<K,V>
      参数：
      k - 键
      v - 值
      返回：
      与k先前关联的值，如果没有则为null
      抛出：
      UnsupportedOperationException - 总是
      自：
      21

    • putLast

      public V putLast(K k, V v)
      抛出UnsupportedOperationException。此映射的比较方法引起的遇到顺序决定了映射的位置，因此不支持显式定位。
      指定由：
      putLast 在接口 SequencedMap<K,V>
      指定由：
      putLast 在接口 SortedMap<K,V>
      参数：
      k - 键
      v - 值
      返回：
      与k先前关联的值，如果没有则为null
      抛出：
      UnsupportedOperationException - 总是
      自：
      21

    • subMap

      public ConcurrentNavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
      从接口复制的描述： NavigableMap
      返回此映射中键范围从fromKey到toKey的部分的视图。如果fromKey和toKey相等，则返回的映射为空，除非fromInclusive和toInclusive都为true。返回的映射由此映射支持，因此返回映射中的更改会反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。

      如果尝试插入超出其范围的键，则返回的映射将抛出IllegalArgumentException，或者构造一个子映射，其任一端点位于其范围之外。

      指定由：
      subMap 在接口 ConcurrentNavigableMap<K,V>
      指定由：
      subMap 在接口 NavigableMap<K,V>
      参数：
      fromKey - 返回的映射中键的低端点
      fromInclusive - 如果要在返回的视图中包含低端点，则为true
      toKey - 返回的映射中键的高端点
      toInclusive - 如果要在返回的视图中包含高端点，则为true
      返回：
      从fromKey到toKey的键范围的视图
      抛出：
      ClassCastException - 如果无法使用此映射的比较器将fromKey和toKey相互比较（或者，如果映射没有比较器，则使用自然排序）。如果fromKey或toKey无法与当前映射中的键进行比较，则实现可能会但不是必须抛出此异常。
      NullPointerException - 如果fromKey或toKey为null
      IllegalArgumentException - 如果fromKey大于toKey；或者如果此映射本身具有受限范围，并且fromKey或toKey位于范围的边界之外

    • headMap

      public ConcurrentNavigableMap<K,V> headMap(K toKey, boolean inclusive)
      从接口复制的描述： NavigableMap
      返回此映射中键小于（如果inclusive为true，则小于或等于）toKey的部分的视图。返回的映射由此映射支持，因此返回映射中的更改会反映在此映射中，反之亦然。返回的映射支持此映射支持的所有可选映射操作。

      如果尝试插入超出其范围的键，则返回的映射将抛出IllegalArgumentException。

      指定由：
      headMap 在接口 ConcurrentNavigableMap<K,V>
      指定由：
      headMap 在接口 NavigableMap<K,V>
      参数：
      toKey - 返回的映射中键的高端点
      inclusive - 如果要在返回的视图中包含高端点，则为true
      返回：
      键小于（如果inclusive为true，则小于或等于）toKey的部分的视图
      抛出：
      ClassCastException - 如果toKey与此映射的比较器不兼容（或者，如果映射没有比较器，则toKey不实现Comparable）。如果实现无法将toKey与当前映射中的键进行比较，则可能但不是必须抛出此异常。
      NullPointerException - 如果toKey为null
      IllegalArgumentException - 如果此映射本身具有受限范围，并且toKey位于范围的边界之外

    • tailMap

      public ConcurrentNavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
      从接口复制的描述： NavigableMap
      返回此地图中键大于（如果inclusive为true，则为大于或等于）fromKey的部分视图。返回的地图由此地图支持，因此返回地图中的更改会反映在此地图中，反之亦然。返回的地图支持此地图支持的所有可选地图操作。

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

      指定者：
      tailMap 在接口 ConcurrentNavigableMap<K,V>
      指定者：
      tailMap 在接口 NavigableMap<K,V>
      参数：
      fromKey - 返回地图中键的低端点
      inclusive - 如果要在返回视图中包含低端点，则为true
      返回：
      一个视图，其中键大于（如果inclusive为true，则为大于或等于）fromKey
      抛出：
      ClassCastException - 如果fromKey与此地图的比较器不兼容（或者，如果地图没有比较器，则如果fromKey未实现Comparable）。如果fromKey无法与当前地图中的键进行比较，则实现可能会但不是必须抛出此异常。
      NullPointerException - 如果fromKey为null
      IllegalArgumentException - 如果此地图本身具有受限范围，并且fromKey超出范围的边界

    • subMap

      public ConcurrentNavigableMap<K,V> subMap(K fromKey, K toKey)
      从接口复制的描述： NavigableMap
      返回此地图中键范围从fromKey（包括）到toKey（不包括）的部分视图。（如果fromKey和toKey相等，则返回的地图为空。）返回的地图由此地图支持，因此返回地图中的更改会反映在此地图中，反之亦然。返回的地图支持此地图支持的所有可选地图操作。

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

      等同于subMap(fromKey, true, toKey, false)。

      指定者：
      subMap 在接口 ConcurrentNavigableMap<K,V>
      指定者：
      subMap 在接口 NavigableMap<K,V>
      指定者：
      subMap 在接口 SortedMap<K,V>
      参数：
      fromKey - 返回地图中键的低端点（包括）
      toKey - 返回地图中键的高端点（不包括）
      返回：
      一个视图，其中键范围从fromKey（包括）到toKey（不包括）
      抛出：
      ClassCastException - 如果fromKey和toKey无法使用此地图的比较器相互比较（或者，如果地图没有比较器，则使用自然排序）。如果fromKey或toKey无法与当前地图中的键进行比较，则实现可能会但不是必须抛出此异常。
      NullPointerException - 如果fromKey或toKey为null
      IllegalArgumentException - 如果fromKey大于toKey；或者如果此地图本身具有受限范围，并且fromKey或toKey超出范围的边界

    • headMap

      public ConcurrentNavigableMap<K,V> headMap(K toKey)
      从接口复制的描述： NavigableMap
      返回此地图中键严格小于toKey的部分视图。返回的地图由此地图支持，因此返回地图中的更改会反映在此地图中，反之亦然。返回的地图支持此地图支持的所有可选地图操作。

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

      等同于headMap(toKey, false)。

      指定者：
      headMap 在接口 ConcurrentNavigableMap<K,V>
      指定者：
      headMap 在接口 NavigableMap<K,V>
      指定者：
      headMap 在接口 SortedMap<K,V>
      参数：
      toKey - 返回地图中键的高端点（不包括）
      返回：
      一个视图，其中键严格小于toKey
      抛出：
      ClassCastException - 如果toKey与此地图的比较器不兼容（或者，如果地图没有比较器，则如果toKey未实现Comparable）。实现可能会但不是必须抛出此异常，如果toKey无法与当前地图中的键进行比较。
      NullPointerException - 如果toKey为null
      IllegalArgumentException - 如果此地图本身具有受限范围，并且toKey超出范围的边界

    • tailMap

      public ConcurrentNavigableMap<K,V> tailMap(K fromKey)
      从接口复制的描述： NavigableMap
      返回此地图中键大于或等于fromKey的部分视图。返回的地图由此地图支持，因此返回地图中的更改会反映在此地图中，反之亦然。返回的地图支持此地图支持的所有可选地图操作。

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

      等同于tailMap(fromKey, true)。

      指定者:
      tailMap 在接口 ConcurrentNavigableMap<K,V>
      指定者:
      tailMap 在接口 NavigableMap<K,V>
      指定者:
      tailMap 在接口 SortedMap<K,V>
      参数:
      fromKey - 返回的地图中键的低端点（包括）
      返回值:
      返回该地图部分的视图，其键大于或等于fromKey
      抛出:
      ClassCastException - 如果fromKey与此地图的比较器不兼容（或者，如果地图没有比较器，并且fromKey没有实现Comparable）。如果fromKey无法与地图中当前的键进行比较，则实现可能会但不是必须抛出此异常。
      NullPointerException - 如果fromKey为null
      IllegalArgumentException - 如果地图本身具有受限范围，并且fromKey位于范围之外的边界

    • lowerEntry

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

    • lowerKey

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

    • floorEntry

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

    • floorKey

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

    • ceilingEntry

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

    • ceilingKey

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

    • higherEntry

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

    • higherKey

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

    • firstEntry

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

    • lastEntry

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

    • pollFirstEntry

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

    • pollLastEntry

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