Module java.base
Package java.util.concurrent

Class ConcurrentHashMap<K,V>

java.lang.Object
java.util.AbstractMap<K,V>
java.util.concurrent.ConcurrentHashMap<K,V>
类型参数:
K - 此映射维护的键的类型
V - 映射值的类型
所有实现的接口:
Serializable, ConcurrentMap<K,V>, Map<K,V>
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable
支持完全并发检索和高预期并发更新的哈希表。此类遵守与Hashtable相同的功能规范，并包括与Hashtable的每个方法对应的方法版本。但是，尽管所有操作都是线程安全的，检索操作不涉及锁定，并且没有任何支持以防止所有访问的方式锁定整个表。这个类与依赖于其线程安全性但不依赖于其同步细节的程序中的Hashtable完全可互操作。

检索操作（包括get）通常不会阻塞，因此可能与更新操作（包括put和remove）重叠。检索反映了最近完成的更新操作在其开始时保持的结果。（更正式地说，给定键的更新操作与报告更新值的任何（非空）检索之间存在happens-before关系。）对于诸如putAll和clear之类的聚合操作，同时进行的检索可能反映了仅对某些条目进行插入或删除。类似地，迭代器、分割器和枚举返回反映哈希表状态的元素，该状态可以是迭代器/枚举创建以来的某个时间点或之后的状态。它们不会抛出ConcurrentModificationException。但是，迭代器设计为一次只由一个线程使用。请记住，包括size、isEmpty和containsValue在内的聚合状态方法的结果通常仅在地图不在其他线程中进行并发更新时才有用。否则，这些方法的结果反映了可能足以用于监视或估计目的，但不适用于程序控制的瞬态状态。

当发生太多冲突（即，具有不同哈希码但落入相同槽的键）时，表会动态扩展，预期平均效果是每个映射维护大约两个存储桶（对应于0.75的负载因子阈值进行调整）。由于添加和删除映射会导致映射的数量发生变化，因此这个平均值可能会有很大的变化，但总体上，这保持了哈希表的一个普遍接受的时间/空间折衷。但是，调整此类或任何其他类型的哈希表可能是一个相对缓慢的操作。如果可能的话，最好提供一个作为可选initialCapacity构造函数参数的大小估计。另一个可选的loadFactor构造函数参数通过指定用于计算为给定元素数量分配的空间量的表密度，提供了进一步定制初始表容量的方法。此外，为了与此类的先前版本兼容，构造函数可以可选地指定一个预期的concurrencyLevel作为内部大小的额外提示。请注意，使用具有完全相同hashCode()的许多键是减慢任何哈希表性能的一种确定方法。为了减轻影响，当键是Comparable时，此类可能使用键之间的比较顺序来帮助打破平局。

可以创建ConcurrentHashMap的Set投影（使用newKeySet()或newKeySet(int)），或查看（使用keySet(Object)当只关注键时，映射值（可能是瞬时的）未被使用或全部采用相同的映射值。

通过使用LongAdder值并通过computeIfAbsent初始化，ConcurrentHashMap可以用作可扩展的频率映射（直方图或多集的一种形式）。例如，要向ConcurrentHashMap<String,LongAdder> freqs添加计数，可以使用freqs.computeIfAbsent(key, k -> new LongAdder()).increment();

此类及其视图和迭代器实现了Map和Iterator接口的所有可选方法。

与Hashtable不同，但与HashMap类似，此类不允许将null用作键或值。

ConcurrentHashMap支持一组顺序和并行的批量操作，与大多数Stream方法不同，这些操作被设计为即使在其他线程正在并发更新地图时也可以安全地应用，并且通常是明智的；例如，在计算共享注册表中值的快照摘要时。有三种操作类型，每种操作类型有四种形式，接受具有键、值、条目和（键、值）对作为参数和/或返回值的函数。由于ConcurrentHashMap的元素没有以任何特定方式排序，并且可能在不同的并行执行中以不同的顺序处理，所以提供的函数的正确性不应依赖于任何排序，或者在计算过程中可能瞬时更改的任何其他对象或值；除了forEach操作外，应该理想地是无副作用的。对于Map.Entry对象的批量操作不支持setValue方法。

  • forEach: 对每个元素执行给定操作。一种变体形式在执行操作之前对每个元素应用给定的转换。
  • search: 返回在每个元素上应用给定函数的第一个可用的非空结果；当找到结果时跳过进一步搜索。
  • reduce: 累积每个元素。提供的减少函数不能依赖排序（更正式地说，它应该既是可结合的又是可交换的）。有五种变体：
    • 普通减少。（对于（键、值）函数参数没有此方法的形式，因为没有相应的返回类型。）
    • 映射减少，累积应用于每个元素的给定函数的结果。
    • 将元素减少为标量双精度、长整型和整型，使用给定的基值。

这些批量操作接受一个parallelismThreshold参数。如果当前映射大小的估计值小于给定阈值，则方法会顺序进行。使用Long.MAX_VALUE的值会抑制所有并行性。使用值1会通过将足够的子任务划分以充分利用用于所有并行计算的ForkJoinPool.commonPool()来实现最大并行性。通常，您最初会选择这些极端值之一，然后测量使用中间值的性能，这些中间值在开销与吞吐量之间进行权衡。

批量操作的并发属性遵循ConcurrentHashMap的属性：从get(key)和相关访问方法返回的任何非空结果与相关插入或更新之间存在happens-before关系。任何批量操作的结果反映了这些每个元素关系的组合（但不一定是与整个映射原子的，除非已知它是静止的）。相反，因为映射中的键和值永远不会为null，所以null作为当前没有任何结果的可靠原子指示器。为了保持这个属性，null作为所有非标量减少操作的隐式基础。对于双精度、长整型和整型版本，基值应该是一个与任何其他值组合时返回该其他值的值（更正式地说，它应该是减少的单位元素）。大多数常见的减少操作具有这些属性；例如，使用基值0计算总和或使用基值MAX_VALUE计算最小值。

作为参数提供的搜索和转换函数应类似地返回null以指示没有任何结果（在这种情况下不使用）。对于映射减少，这也使得转换可以作为过滤器，如果元素不应组合，则返回null（或者在原始专业化的情况下，返回身份基础）。在使用它们进行搜索或减少操作之前，您可以根据这个“null表示现在没有任何东西”的规则自己组合转换和过滤。

接受和/或返回Entry参数的方法维护键-值关联。例如，在查找最大值的键时可能会有用。请注意，“普通”Entry参数可以使用new AbstractMap.SimpleEntry(k,v)提供。

批量操作可能会突然完成，抛出在应用提供的函数时遇到的异常。请注意，在处理这些异常时，其他同时执行的函数也可能会抛出异常，或者如果第一个异常没有发生，则可能会发生异常。

与顺序形式相比，并行形式的加速常见但不保证。在小地图上涉及简短函数的并行操作可能比顺序形式执行更慢，如果用于并行化计算的底层工作比计算本身更昂贵。同样，如果所有处理器都忙于执行不相关的任务，则并行化可能不会导致实际并行化。

所有任务方法的所有参数都必须是非null的。

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

自版本:
1.5
参见:

  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    static final class 
    ConcurrentHashMap.KeySetView<K,V>
    作为键的ConcurrentHashMap的Set视图，其中可以通过映射到公共值来选择启用添加。

    Nested classes/interfaces declared in class java.util.AbstractMap

    AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>

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

    Map.Entry<K,V>

  • Constructor Summary

    Constructors
    Constructor
    Description
    ConcurrentHashMap()
    创建一个新的空映射，其默认初始表大小为16。
    ConcurrentHashMap(int initialCapacity)
    创建一个新的空映射，其初始表大小适应指定数量的元素而无需动态调整大小。
    ConcurrentHashMap(int initialCapacity, float loadFactor)
    创建一个新的空映射，初始表大小基于给定的元素数量（initialCapacity）和初始表密度（loadFactor）。
    ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
    创建一个新的空映射，初始表大小基于给定的元素数量（initialCapacity），初始表密度（loadFactor）和同时更新线程数（concurrencyLevel）。
    ConcurrentHashMap(Map<? extends K,? extends V> m)
    创建一个具有与给定映射相同映射的新映射。

  • Method Summary

    Modifier and Type
    Method
    Description
    void
    clear()
    从此映射中删除所有映射。
    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
    contains(Object value)
    测试某个键是否映射到此表中的指定值。
    boolean
    containsKey(Object key)
    测试指定对象是否为此表中的键。
    boolean
    containsValue(Object value)
    如果此映射将一个或多个键映射到指定值，则返回true。
    Enumeration<V>
    elements()
    返回此表中值的枚举。
    Set<Map.Entry<K,V>>
    entrySet()
    返回包含此映射中的映射的Set视图。
    boolean
    equals(Object o)
    将指定对象与此映射进行比较以检查相等性。
    void
    forEach(long parallelismThreshold, BiConsumer<? super K,? super V> action)
    对每个（键，值）执行给定操作。
    <U> void
    forEach(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> transformer, Consumer<? super U> action)
    对每个非空的（键，值）变换执行给定操作。
    void
    forEachEntry(long parallelismThreshold, Consumer<? super Map.Entry<K,V>> action)
    对每个条目执行给定操作。
    <U> void
    forEachEntry(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> transformer, Consumer<? super U> action)
    对每个非空的条目变换执行给定操作。
    void
    forEachKey(long parallelismThreshold, Consumer<? super K> action)
    对每个键执行给定操作。
    <U> void
    forEachKey(long parallelismThreshold, Function<? super K,? extends U> transformer, Consumer<? super U> action)
    对每个非空的键变换执行给定操作。
    void
    forEachValue(long parallelismThreshold, Consumer<? super V> action)
    对每个值执行给定操作。
    <U> void
    forEachValue(long parallelismThreshold, Function<? super V,? extends U> transformer, Consumer<? super U> action)
    对每个非空的值变换执行给定操作。
    V
    get(Object key)
    返回指定键映射到的值，如果此映射不包含键的映射，则返回null。
    V
    getOrDefault(Object key, V defaultValue)
    返回指定键映射到的值，如果此映射不包含键的映射，则返回给定的默认值。
    int
    hashCode()
    返回此Map的哈希码值，即映射中每个键-值对的key.hashCode() ^ value.hashCode()之和。
    boolean
    isEmpty()
    如果此映射不包含键-值映射，则返回true。
    Enumeration<K>
    keys()
    返回此表中键的枚举。
    ConcurrentHashMap.KeySetView<K,V>
    keySet()
    返回包含此映射中键的Set视图。
    ConcurrentHashMap.KeySetView<K,V>
    keySet(V mappedValue)
    返回包含此映射中键的Set视图，对于任何添加使用给定公共映射值的情况（即Collection.add(E)和Collection.addAll(Collection)）。
    long
    mappingCount()
    返回映射的数量。
    V
    merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
    如果指定的键尚未与（非空）值关联，则将其与给定值关联。
    static <K> ConcurrentHashMap.KeySetView<K,Boolean>
    newKeySet()
    创建一个由给定类型到Boolean.TRUE的ConcurrentHashMap支持的新Set。
    static <K> ConcurrentHashMap.KeySetView<K,Boolean>
    newKeySet(int initialCapacity)
    创建一个由给定类型到Boolean.TRUE的ConcurrentHashMap支持的新Set。
    V
    put(K key, V value)
    在此表中将指定的键映射到指定的值。
    void
    putAll(Map<? extends K,? extends V> m)
    将指定映射中的所有映射复制到此映射中。
    V
    putIfAbsent(K key, V value)
    如果指定的键尚未与值关联，则将其与给定值关联。
    <U> U
    reduce(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer)
    使用给定的转换和减少器对所有（键，值）对进行累积操作的结果，如果没有则返回null。
    Map.Entry<K,V>
    reduceEntries(long parallelismThreshold, BiFunction<Map.Entry<K,V>,Map.Entry<K,V>,? extends Map.Entry<K,V>> reducer)
    使用给定的减少器对所有条目进行累积操作的结果，如果没有则返回null。
    <U> U
    reduceEntries(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer)
    使用给定的转换和减少器对所有条目进行累积操作的结果，如果没有则返回null。
    double
    reduceEntriesToDouble(long parallelismThreshold, ToDoubleFunction<Map.Entry<K,V>> transformer, double basis, DoubleBinaryOperator reducer)
    使用给定的转换和减少器对所有条目进行累积操作的结果，并将给定的基础作为标识值返回。
    int
    reduceEntriesToInt(long parallelismThreshold, ToIntFunction<Map.Entry<K,V>> transformer, int basis, IntBinaryOperator reducer)
    使用给定的转换和减少器对所有条目进行累积操作的结果，并将给定的基础作为标识值返回。
    long
    reduceEntriesToLong(long parallelismThreshold, ToLongFunction<Map.Entry<K,V>> transformer, long basis, LongBinaryOperator reducer)
    使用给定的转换和减少器对所有条目进行累积操作的结果，并将给定的基础作为标识值返回。
    K
    reduceKeys(long parallelismThreshold, BiFunction<? super K,? super K,? extends K> reducer)
    使用给定的减少器对所有键进行累积操作的结果，如果没有则返回null。
    <U> U
    reduceKeys(long parallelismThreshold, Function<? super K,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer)
    使用给定的转换和减少器对所有键进行累积操作的结果，如果没有则返回null。
    double
    reduceKeysToDouble(long parallelismThreshold, ToDoubleFunction<? super K> transformer, double basis, DoubleBinaryOperator reducer)
    使用给定的转换和减少器对所有键进行累积操作的结果，并将给定的基础作为标识值返回。
    int
    reduceKeysToInt(long parallelismThreshold, ToIntFunction<? super K> transformer, int basis, IntBinaryOperator reducer)
    使用给定的转换和减少器对所有键进行累积操作的结果，并将给定的基础作为标识值返回。
    long
    reduceKeysToLong(long parallelismThreshold, ToLongFunction<? super K> transformer, long basis, LongBinaryOperator reducer)
    使用给定的转换和减少器对所有键进行累积操作的结果，并将给定的基础作为标识值返回。
    double
    reduceToDouble(long parallelismThreshold, ToDoubleBiFunction<? super K,? super V> transformer, double basis, DoubleBinaryOperator reducer)
    使用给定的转换和减少器对所有（键，值）对进行累积操作的结果，并将给定的基础作为标识值返回。
    int
    reduceToInt(long parallelismThreshold, ToIntBiFunction<? super K,? super V> transformer, int basis, IntBinaryOperator reducer)
    使用给定的转换和减少器对所有（键，值）对进行累积操作的结果，并将给定的基础作为标识值返回。
    long
    reduceToLong(long parallelismThreshold, ToLongBiFunction<? super K,? super V> transformer, long basis, LongBinaryOperator reducer)
    使用给定的转换和减少器对所有（键，值）对进行累积操作的结果，并将给定的基础作为标识值返回。
    V
    reduceValues(long parallelismThreshold, BiFunction<? super V,? super V,? extends V> reducer)
    使用给定的减少器对所有值进行累积操作的结果，如果没有则返回null。
    <U> U
    reduceValues(long parallelismThreshold, Function<? super V,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer)
    使用给定的转换和减少器对所有值进行累积操作的结果，如果没有则返回null。
    double
    reduceValuesToDouble(long parallelismThreshold, ToDoubleFunction<? super V> transformer, double basis, DoubleBinaryOperator reducer)
    使用给定的转换和减少器对所有值进行累积操作的结果，并将给定的基础作为标识值返回。
    int
    reduceValuesToInt(long parallelismThreshold, ToIntFunction<? super V> transformer, int basis, IntBinaryOperator reducer)
    使用给定的转换和减少器对所有值进行累积操作的结果，并将给定的基础作为标识值返回。
    long
    reduceValuesToLong(long parallelismThreshold, ToLongFunction<? super V> transformer, long basis, LongBinaryOperator reducer)
    使用给定的转换和减少器对所有值进行累积操作的结果，并将给定的基础作为标识值返回。
    V
    remove(Object key)
    从此映射中删除键（及其对应的值）。
    boolean
    remove(Object key, Object value)
    仅当键当前映射到给定值时，才删除键的条目。
    V
    replace(K key, V value)
    仅当键当前映射到某个值时，才替换键的条目。
    boolean
    replace(K key, V oldValue, V newValue)
    仅当键当前映射到给定值时，才替换键的条目。
    <U> U
    search(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> searchFunction)
    对每个（键，值）应用给定搜索函数，返回非空结果，如果没有则返回null。
    <U> U
    searchEntries(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> searchFunction)
    对每个条目应用给定搜索函数，返回非空结果，如果没有则返回null。
    <U> U
    searchKeys(long parallelismThreshold, Function<? super K,? extends U> searchFunction)
    对每个键应用给定搜索函数，返回非空结果，如果没有则返回null。
    <U> U
    searchValues(long parallelismThreshold, Function<? super V,? extends U> searchFunction)
    对每个值应用给定搜索函数，返回非空结果，如果没有则返回null。
    int
    size()
    返回此映射中键-值映射的数量。
    String
    toString()
    返回此映射的字符串表示形式。
    Collection<V>
    values()
    返回包含此映射中值的Collection视图。

    Methods declared in class java.util.AbstractMap

    clone, isEmpty, size

    Methods declared in class java.lang.Object

    finalize, getClass, notify, notifyAll, wait, wait, wait

    Methods declared in interface java.util.concurrent.ConcurrentMap

    forEach, replaceAll

  • Constructor Details

    • ConcurrentHashMap

      public ConcurrentHashMap()
      创建一个新的空映射，具有默认的初始表大小（16）。

    • ConcurrentHashMap

      public ConcurrentHashMap(int initialCapacity)
      创建一个新的空映射，其初始表大小适应指定数量的元素，无需动态调整大小。
      参数:
      initialCapacity - 实现内部调整大小以容纳这么多元素。
      抛出:
      IllegalArgumentException - 如果元素的初始容量为负数

    • ConcurrentHashMap

      public ConcurrentHashMap(Map<? extends K,? extends V> m)
      创建一个具有与给定映射相同映射的新映射。
      参数:
      m - 映射

    • ConcurrentHashMap

      public ConcurrentHashMap(int initialCapacity, float loadFactor)
      创建一个新的空映射，其初始表大小基于给定的元素数量（initialCapacity）和初始表密度（loadFactor）。
      参数:
      initialCapacity - 初始容量。实现内部调整大小以容纳这么多元素，给定指定的负载因子。
      loadFactor - 用于建立初始表大小的负载因子（表密度）
      抛出:
      IllegalArgumentException - 如果元素的初始容量为负数或负载因子为非正数
      自1.6版本起:
      1.6

    • ConcurrentHashMap

      public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
      创建一个新的空映射，其初始表大小基于给定的元素数量（initialCapacity），初始表密度（loadFactor）和同时更新线程数（concurrencyLevel）。
      参数:
      initialCapacity - 初始容量。实现会执行内部调整以容纳这么多元素，考虑到指定的负载因子。
      loadFactor - 负载因子（表密度），用于确定初始表大小
      concurrencyLevel - 预估的并发更新线程数。实现可能会将此值用作大小提示。
      抛出:
      IllegalArgumentException - 如果初始容量为负数或负载因子或concurrencyLevel为非正数

  • Method Details

    • 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

    • get

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

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

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

    • containsKey

      public boolean containsKey(Object key)
      测试指定对象是否为此表中的键。
      指定者:
      containsKey 在接口 Map<K,V>中
      覆盖:
      containsKey 在类 AbstractMap<K,V>中
      参数:
      key - 可能的键
      返回:
      如果指定对象是此表中的键（由equals方法确定），则返回true；否则返回false
      抛出:
      NullPointerException - 如果指定的键为null

    • containsValue

      public boolean containsValue(Object value)
      如果此映射将一个或多个键映射到指定值，则返回true。注意：此方法可能需要对映射进行完整遍历，比containsKey方法慢得多。
      指定者:
      containsValue 在接口 Map<K,V>中
      覆盖:
      containsValue 在类 AbstractMap<K,V>中
      参数:
      value - 要测试其在此映射中的存在性的值
      返回:
      如果此映射将一个或多个键映射到指定值，则返回true
      抛出:
      NullPointerException - 如果指定的值为null

    • put

      public V put(K key, V value)
      在此表中将指定键映射到指定值。键和值都不能为null。

      可以通过使用等于原始键的键调用get方法来检索值。

      指定者:
      put 在接口 Map<K,V>中
      覆盖:
      put 在类 AbstractMap<K,V>中
      参数:
      key - 要与指定值关联的键
      value - 要与指定键关联的值
      返回:
      与key关联的先前值，如果key没有映射，则返回null
      抛出:
      NullPointerException - 如果指定的键或值为null

    • putAll

      public void putAll(Map<? extends K,? extends V> m)
      将指定映射中的所有映射复制到此映射中。这些映射将替换此映射当前对于指定映射中当前任何键的任何映射。
      指定者:
      putAll 在接口 Map<K,V>中
      覆盖:
      putAll 在类 AbstractMap<K,V>中
      参数:
      m - 要存储在此映射中的映射

    • remove

      public V remove(Object key)
      从此映射中删除键（及其对应的值）。如果键不在映射中，则此方法不执行任何操作。
      指定者:
      remove 在接口 Map<K,V>中
      覆盖:
      remove 在类 AbstractMap<K,V>中
      参数:
      key - 需要被移除的键
      返回:
      与key关联的先前值，如果key没有映射，则返回null
      抛出:
      NullPointerException - 如果指定的键为null

    • clear

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

    • keySet

      public ConcurrentHashMap.KeySetView<K,V> keySet()
      返回此映射中包含的键的Set视图。该集合由映射支持，因此对映射的更改会反映在集合中，反之亦然。该集合支持元素移除，通过Iterator.remove、Set.remove、removeAll、retainAll和clear操作从此映射中删除相应的映射。它不支持add或addAll操作。

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

      该视图的spliterator报告Spliterator.CONCURRENT、Spliterator.DISTINCT和Spliterator.NONNULL。

      指定者:
      keySet 在接口 Map<K,V>中
      覆盖:
      keySet 在类 AbstractMap<K,V>中
      返回:
      集合视图

    • values

      public Collection<V> values()
      返回此映射中包含的值的Collection视图。该集合由映射支持，因此对映射的更改会反映在集合中，反之亦然。该集合支持元素移除，通过Iterator.remove、Collection.remove、removeAll、retainAll和clear操作从此映射中删除相应的映射。它不支持add或addAll操作。

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

      该视图的spliterator报告Spliterator.CONCURRENT和Spliterator.NONNULL。

      指定者:
      values 在接口 Map<K,V>中
      覆盖:
      values 在类 AbstractMap<K,V>中
      返回:
      集合视图

    • entrySet

      public Set<Map.Entry<K,V>> entrySet()
      返回此映射中包含的映射的Set视图。该集合由映射支持，因此对映射的更改会反映在集合中，反之亦然。该集合支持元素移除，通过Iterator.remove、Set.remove、removeAll、retainAll和clear操作从映射中删除相应的映射。

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

      该视图的spliterator报告Spliterator.CONCURRENT、Spliterator.DISTINCT和Spliterator.NONNULL。

      指定者:
      entrySet 在接口 Map<K,V>中
      返回:
      集合视图

    • hashCode

      public int hashCode()
      返回此Map的哈希码值，即对于映射中的每个键-值对，计算key.hashCode() ^ value.hashCode()的总和。
      指定者:
      hashCode 在接口 Map<K,V>中
      覆盖:
      hashCode 在类 AbstractMap<K,V>中
      返回:
      此映射的哈希码值
      参见:

    • toString

      public String toString()
      返回此映射的字符串表示形式。字符串表示形式由用大括号("{}")括起来的键-值映射列表（没有特定顺序）组成。相邻的映射由字符", "（逗号和空格）分隔。每个键-值映射都以键后跟等号("=")再跟相关值的形式呈现。
      覆盖:
      toString 在类 AbstractMap<K,V>中
      返回:
      此映射的字符串表示形式

    • equals

      public boolean equals(Object o)
      将指定对象与此映射进行比较以检查相等性。如果给定对象是具有与此映射相同映射的映射，则返回true。如果在执行此方法期间同时修改任一映射，则此操作可能返回误导性的结果。
      指定者:
      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
      抛出:
      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
      抛出:
      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
      抛出:
      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
      抛出:
      NullPointerException - 如果指定的键或值为null

    • getOrDefault

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

    • 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 - 如果指定的键或mappingFunction为null
      IllegalStateException - 如果计算检测到尝试对此映射进行递归更新，否则永远无法完成
      RuntimeException - 或错误，如果mappingFunction这样做，则映射将保持未建立状态

    • 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 - 如果指定的键或remappingFunction为null
      IllegalStateException - 如果计算检测到尝试对此映射进行递归更新，否则永远无法完成
      RuntimeException - 或错误，如果remappingFunction这样做，则映射将保持不变

    • 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 - 如果指定的键或remappingFunction为null
      IllegalStateException - 如果计算明显尝试对此映射进行递归更新，否则永远无法完成
      RuntimeException - 或错误，如果remappingFunction这样做，此时映射不会更改

    • merge

      public V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
      如果指定的键尚未与（非null）值关联，则将其与给定值关联。否则，用给定重映射函数的结果替换该值，如果为null则移除。整个方法调用是原子性的。在计算进行中，其他线程对此映射的一些尝试更新操作可能会被阻塞，因此计算应该简短且简单，并且不得尝试更新此Map的任何其他映射。
      指定者:
      merge 在接口 ConcurrentMap<K,V>中
      指定者:
      merge 在接口 Map<K,V>中
      参数:
      key - 要关联指定值的键
      value - 如果不存在则使用的值
      remappingFunction - 如果存在则重新计算值的函数
      返回:
      与指定键关联的新值，如果没有则为null
      抛出:
      NullPointerException - 如果指定的键或remappingFunction为null
      RuntimeException - 或错误，如果remappingFunction这样做，此时映射不会更改

    • contains

      public boolean contains(Object value)
      测试某个键是否映射到此表中的指定值。

      请注意，此方法在功能上与containsValue(Object)完全相同，仅存在是为了确保与Hashtable类的完全兼容性，该类在引入Java集合框架之前支持此方法。

      参数:
      value - 要搜索的值
      返回:
      如果某个键根据equals方法在此表中映射到value参数，则为true；否则为false
      抛出:
      NullPointerException - 如果指定的值为null

    • keys

      public Enumeration<K> keys()
      返回此表中键的枚举。
      返回:
      此表中键的枚举
      参见:

    • elements

      public Enumeration<V> elements()
      返回此表中值的枚举。
      返回:
      此表中值的枚举
      参见:

    • mappingCount

      public long mappingCount()
      返回映射的数量。应该使用此方法而不是size()，因为ConcurrentHashMap可能包含的映射数量可能超过int所能表示的数量。返回的值是一个估计值；如果存在并发插入或删除，则实际计数可能不同。
      返回:
      映射的数量
      自1.8起:
      1.8

    • newKeySet

      public static <K> ConcurrentHashMap.KeySetView<K,Boolean> newKeySet()
      创建一个新的由给定类型到Boolean.TRUE的ConcurrentHashMap支持的Set。
      类型参数:
      K - 返回集合的元素类型
      返回:
      新的集合
      自1.8起:
      1.8

    • newKeySet

      public static <K> ConcurrentHashMap.KeySetView<K,Boolean> newKeySet(int initialCapacity)
      创建一个新的由给定类型到Boolean.TRUE的ConcurrentHashMap支持的Set。
      类型参数:
      K - 返回集合的元素类型
      参数:
      initialCapacity - 实现执行内部大小调整以容纳这么多元素。
      返回:
      新的集合
      抛出:
      IllegalArgumentException - 如果元素的初始容量为负
      自1.8起:
      1.8

    • keySet

      public ConcurrentHashMap.KeySetView<K,V> keySet(V mappedValue)
      返回此映射中键的Set视图，对于任何添加（即，Collection.add(E)和Collection.addAll(Collection)）都使用给定的公共映射值。当然，只有在可以接受从此视图的所有添加使用相同值时才适用。
      参数:
      mappedValue - 用于任何添加的映射值
      返回:
      集合视图
      抛出:
      NullPointerException - 如果mappedValue为null

    • forEach

      public void forEach(long parallelismThreshold, BiConsumer<? super K,? super V> action)
      对每个（键，值）执行给定操作。
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计）元素数量
      action - 操作
      自1.8起:
      1.8

    • forEach

      public <U> void forEach(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> transformer, Consumer<? super U> action)
      对每个非null转换的（键，值）执行给定操作。
      类型参数:
      U - 转换器的返回类型
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计）元素数量
      transformer - 返回元素的转换的函数，如果没有转换则为null（在这种情况下不应用操作）
      action - 操作
      自1.8起:
      1.8

    • search

      public <U> U search(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> searchFunction)
      返回在每个（键，值）上应用给定搜索函数的非null结果，如果没有则为null。成功后，将抑制进一步元素处理，并忽略搜索函数的任何其他并行调用的结果。
      类型参数:
      U - 搜索函数的返回类型
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计）元素数量
      searchFunction - 在成功时返回非null结果，否则为null的函数
      返回:
      在每个（键，值）上应用给定搜索函数的非null结果，如果没有则为null
      自1.8起:
      1.8

    • reduce

      public <U> U reduce(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer)
      返回使用给定的缩减器组合值的给定转换的所有（键，值）对的结果，如果没有则为null。
      类型参数:
      U - 转换器的返回类型
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计）元素数量
      transformer - 返回元素的转换的函数，如果没有转换则不组合
      reducer - 一个可交换的关联组合函数
      返回:
      使用给定转换的所有（键，值）对的结果
      自1.8起:
      1.8

    • reduceToDouble

      public double reduceToDouble(long parallelismThreshold, ToDoubleBiFunction<? super K,? super V> transformer, double basis, DoubleBinaryOperator reducer)
      返回使用给定缩减器组合值的给定转换的所有（键，值）对的结果，并使用给定基础作为标识值。
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计）元素数量
      transformer - 返回元素的转换的函数
      basis - 用于缩减的标识（初始默认值）
      reducer - 一个可交换的关联组合函数
      返回:
      使用给定转换的所有（键，值）对的结果
      自1.8起:
      1.8

    • reduceToLong

      public long reduceToLong(long parallelismThreshold, ToLongBiFunction<? super K,? super V> transformer, long basis, LongBinaryOperator reducer)
      返回使用给定缩减器组合值的给定转换的所有（键，值）对的结果，并使用给定基础作为标识值。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数
      basis - 用于减少的标识（初始默认值）
      reducer - 可交换的结合函数
      返回:
      所有（键，值）对的给定转换累积的结果
      自1.8版本起:
      1.8

    • reduceToInt

      public int reduceToInt(long parallelismThreshold, ToIntBiFunction<? super K,? super V> transformer, int basis, IntBinaryOperator reducer)
      使用给定的reducer组合值和给定的basis作为标识值，返回给定转换的所有（键，值）对的累积结果。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数
      basis - 用于减少的标识（初始默认值）
      reducer - 可交换的结合函数
      返回:
      所有（键，值）对的给定转换累积的结果
      自1.8版本起:
      1.8

    • forEachKey

      public void forEachKey(long parallelismThreshold, Consumer<? super K> action)
      对每个键执行给定操作。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      action - 操作
      自1.8版本起:
      1.8

    • forEachKey

      public <U> void forEachKey(long parallelismThreshold, Function<? super K,? extends U> transformer, Consumer<? super U> action)
      对每个键的每个非空转换执行给定操作。
      类型参数:
      U - 转换器的返回类型
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数，如果没有转换则为null（在这种情况下不应用操作）
      action - 操作
      自1.8版本起:
      1.8

    • searchKeys

      public <U> U searchKeys(long parallelismThreshold, Function<? super K,? extends U> searchFunction)
      对每个键应用给定搜索函数并返回非空结果，如果没有则返回null。成功后，将抑制进一步的元素处理，并忽略搜索函数的任何其他并行调用的结果。
      类型参数:
      U - 搜索函数的返回类型
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      searchFunction - 在成功时返回非空结果，否则返回null的函数
      返回:
      对每个键应用给定搜索函数并返回非空结果，如果没有则返回null
      自1.8版本起:
      1.8

    • reduceKeys

      public K reduceKeys(long parallelismThreshold, BiFunction<? super K,? super K,? extends K> reducer)
      使用给定reducer组合值累积所有键的结果，如果没有则返回null。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      reducer - 可交换的结合函数
      返回:
      使用给定reducer组合值累积所有键的结果，如果没有则返回null
      自1.8版本起:
      1.8

    • reduceKeys

      public <U> U reduceKeys(long parallelismThreshold, Function<? super K,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer)
      使用给定reducer组合值累积所有键的给定转换的结果，如果没有则返回null。
      类型参数:
      U - 转换器的返回类型
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数，如果没有转换则不组合
      reducer - 可交换的结合函数
      返回:
      使用给定reducer组合值累积所有键的给定转换的结果
      自1.8版本起:
      1.8

    • reduceKeysToDouble

      public double reduceKeysToDouble(long parallelismThreshold, ToDoubleFunction<? super K> transformer, double basis, DoubleBinaryOperator reducer)
      使用给定reducer组合值累积所有键的给定转换的结果，并使用给定basis作为标识值。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数
      basis - 用于减少的标识（初始默认值）
      reducer - 可交换的结合函数
      返回:
      使用给定reducer组合值累积所有键的给定转换的结果
      自1.8版本起:
      1.8

    • reduceKeysToLong

      public long reduceKeysToLong(long parallelismThreshold, ToLongFunction<? super K> transformer, long basis, LongBinaryOperator reducer)
      使用给定reducer组合值累积所有键的给定转换的结果，并使用给定basis作为标识值。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数
      basis - 用于减少的标识（初始默认值）
      reducer - 可交换的结合函数
      返回:
      使用给定reducer组合值累积所有键的给定转换的结果
      自1.8版本起:
      1.8

    • reduceKeysToInt

      public int reduceKeysToInt(long parallelismThreshold, ToIntFunction<? super K> transformer, int basis, IntBinaryOperator reducer)
      使用给定reducer组合值累积所有键的给定转换的结果，并使用给定basis作为标识值。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数
      basis - 用于减少的标识（初始默认值）
      reducer - 可交换的结合函数
      返回:
      使用给定reducer组合值累积所有键的给定转换的结果
      自1.8版本起:
      1.8

    • forEachValue

      public void forEachValue(long parallelismThreshold, Consumer<? super V> action)
      对每个值执行给定操作。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      action - 操作
      自1.8版本起:
      1.8

    • forEachValue

      public <U> void forEachValue(long parallelismThreshold, Function<? super V,? extends U> transformer, Consumer<? super U> action)
      对每个值的每个非空转换执行给定操作。
      类型参数:
      U - 转换器的返回类型
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数，如果没有转换则为null（在这种情况下不应用操作）
      action - 操作
      自1.8版本起:
      1.8

    • searchValues

      public <U> U searchValues(long parallelismThreshold, Function<? super V,? extends U> searchFunction)
      对每个值应用给定搜索函数并返回非空结果，如果没有则返回null。成功后，将抑制进一步的元素处理，并忽略搜索函数的任何其他并行调用的结果。
      类型参数:
      U - 搜索函数的返回类型
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      searchFunction - 在成功时返回非空结果，否则返回null的函数
      返回:
      对每个值应用给定搜索函数并返回非空结果，如果没有则返回null
      自1.8版本起:
      1.8

    • reduceValues

      public V reduceValues(long parallelismThreshold, BiFunction<? super V,? super V,? extends V> reducer)
      使用给定reducer组合值累积所有值的结果，如果没有则返回null。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      reducer - 可交换的结合函数
      返回:
      使用给定reducer组合值累积所有值的结果
      自1.8版本起:
      1.8

    • reduceValues

      public <U> U reduceValues(long parallelismThreshold, Function<? super V,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer)
      使用给定reducer组合值累积所有值的给定转换的结果，如果没有则返回null。
      类型参数:
      U - 转换器的返回类型
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数，如果没有转换则不组合
      reducer - 可交换的结合函数
      返回:
      使用给定reducer组合值累积所有值的给定转换的结果
      自1.8版本起:
      1.8

    • reduceValuesToDouble

      public double reduceValuesToDouble(long parallelismThreshold, ToDoubleFunction<? super V> transformer, double basis, DoubleBinaryOperator reducer)
      使用给定reducer组合值累积所有值的给定转换的结果，并使用给定basis作为标识值。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数
      basis - 用于减少的标识（初始默认值）
      reducer - 可交换的结合函数
      返回:
      使用给定reducer组合值累积所有值的给定转换的结果
      自1.8版本起:
      1.8

    • reduceValuesToLong

      public long reduceValuesToLong(long parallelismThreshold, ToLongFunction<? super V> transformer, long basis, LongBinaryOperator reducer)
      使用给定reducer组合值累积所有值的给定转换的结果，并使用给定basis作为标识值。
      参数:
      parallelismThreshold - 执行此操作需要并行执行的元素数量（估计值）
      transformer - 返回元素转换的函数
      basis - 用于减少的标识（初始默认值）
      reducer - 可交换的结合函数
      返回:
      使用给定reducer组合值累积所有值的给定转换的结果
      自1.8版本起:
      1.8

    • reduceValuesToInt

      public int reduceValuesToInt(long parallelismThreshold, ToIntFunction<? super V> transformer, int basis, IntBinaryOperator reducer)
      返回使用给定的reducer将所有值的给定转换累积起来的结果，并使用给定的basis作为身份值。
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计的）元素数量
      transformer - 返回元素转换的函数
      basis - 用于减少的身份（初始默认值）
      reducer - 可交换的结合函数
      返回:
      所有值的给定转换累积的结果
      自版本:
      1.8

    • forEachEntry

      public void forEachEntry(long parallelismThreshold, Consumer<? super Map.Entry<K,V>> action)
      对每个条目执行给定的操作。
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计的）元素数量
      action - 操作
      自版本:
      1.8

    • forEachEntry

      public <U> void forEachEntry(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> transformer, Consumer<? super U> action)
      对每个条目的非空转换执行给定的操作。
      类型参数:
      U - 转换器的返回类型
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计的）元素数量
      transformer - 返回元素转换的函数，如果没有转换则为null（在这种情况下不应用操作）
      action - 操作
      自版本:
      1.8

    • searchEntries

      public <U> U searchEntries(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> searchFunction)
      对每个条目应用给定搜索函数并返回非空结果，如果没有则返回null。成功后，将抑制进一步的元素处理，并忽略搜索函数的任何其他并行调用的结果。
      类型参数:
      U - 搜索函数的返回类型
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计的）元素数量
      searchFunction - 在成功时返回非空结果，否则返回null的函数
      返回:
      对每个条目应用给定搜索函数并返回非空结果，如果没有则返回null
      自版本:
      1.8

    • reduceEntries

      public Map.Entry<K,V> reduceEntries(long parallelismThreshold, BiFunction<Map.Entry<K,V>,Map.Entry<K,V>,? extends Map.Entry<K,V>> reducer)
      使用给定的reducer将所有条目组合起来的结果，如果没有则返回null。
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计的）元素数量
      reducer - 可交换的结合函数
      返回:
      将所有条目组合起来的结果
      自版本:
      1.8

    • reduceEntries

      public <U> U reduceEntries(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer)
      使用给定的reducer将所有条目的给定转换累积起来的结果，如果没有则返回null。
      类型参数:
      U - 转换器的返回类型
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计的）元素数量
      transformer - 返回元素转换的函数，如果没有转换则为null（在这种情况下不组合）
      reducer - 可交换的结合函数
      返回:
      使用给定的reducer将所有条目的给定转换累积起来的结果
      自版本:
      1.8

    • reduceEntriesToDouble

      public double reduceEntriesToDouble(long parallelismThreshold, ToDoubleFunction<Map.Entry<K,V>> transformer, double basis, DoubleBinaryOperator reducer)
      使用给定的reducer将所有条目的给定转换累积起来的结果，并使用给定的basis作为身份值。
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计的）元素数量
      transformer - 返回元素转换的函数
      basis - 用于减少的身份（初始默认值）
      reducer - 可交换的结合函数
      返回:
      使用给定的reducer将所有条目的给定转换累积起来的结果
      自版本:
      1.8

    • reduceEntriesToLong

      public long reduceEntriesToLong(long parallelismThreshold, ToLongFunction<Map.Entry<K,V>> transformer, long basis, LongBinaryOperator reducer)
      使用给定的reducer将所有条目的给定转换累积起来的结果，并使用给定的basis作为身份值。
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计的）元素数量
      transformer - 返回元素转换的函数
      basis - 用于减少的身份（初始默认值）
      reducer - 可交换的结合函数
      返回:
      使用给定的reducer将所有条目的给定转换累积起来的结果
      自版本:
      1.8

    • reduceEntriesToInt

      public int reduceEntriesToInt(long parallelismThreshold, ToIntFunction<Map.Entry<K,V>> transformer, int basis, IntBinaryOperator reducer)
      使用给定的reducer将所有条目的给定转换累积起来的结果，并使用给定的basis作为身份值。
      参数:
      parallelismThreshold - 需要并行执行此操作的（估计的）元素数量
      transformer - 返回元素转换的函数
      basis - 用于减少的身份（初始默认值）
      reducer - 可交换的结合函数
      返回:
      使用给定的reducer将所有条目的给定转换累积起来的结果
      自版本:
      1.8