模块  java.base
软件包  java.util.concurrent

Class 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完全可互操作， Hashtable程序依赖于其线程安全性，但不依赖于其同步细节。

    检索操作（包括get ）一般不会阻塞，因此可能与更新操作重叠（包括put和remove ）。 检索反映了最近完成的更新操作的结果。 （更正式地说，给定密钥的更新操作承担与报告更新值的该密钥的任何（非空）检索之前发生的关系。）对于诸如putAll和clear类的聚合操作，并发检索可能反映插入或删除只有一些条目。 类似地，Iterators，Spliterators和Enumerations在迭代器/枚举的创建时或之后的某个时刻返回反映哈希表状态的元素。 他们不扔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用作键或值。

    ConcurrentHashMaps支持一组顺序和并行批量操作，与大多数Stream方法不同，它们被设计为安全且通常合理地应用，即使是由其他线程同时更新的映射; 例如，在共享注册表中计算值的快照摘要时。 有三种操作，每种操作有四种形式，接受带有键，值，条目和（键，值）对的函数作为参数和/或返回值。 因为ConcurrentHashMap的元素没有以任何特定的方式排序，并且可以在不同的并行执行中以不同的顺序处理，所提供的函数的正确性不应该依赖于任何排序，或者可能依赖于任何其他可能瞬时变化的对象或值。计算正在进行中; 除了forEach动作外，理想情况下应该是无副作用的。 Map.Entry对象上的批量操作不支持方法setValue 。

    • forEach：对每个元素执行给定的操作。 变量形式在执行操作之前对每个元素应用给定的变换。
    • search：返回在每个元素上应用给定函数的第一个可用的非null结果; 在找到结果时跳过进一步搜索。
    • reduce：累积每个元素。 提供的缩减功能不能依赖于排序（更正式地说，它应该是关联的和可交换的）。 有五种变体：
      • 简单减少。 （对于（key，value）函数参数，没有这种方法的形式，因为没有相应的返回类型。）
      • 映射缩减，累积应用于每个元素的给定函数的结果。
      • 使用给定的基值减少标量的双精度，长数和整数。

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

    批量操作的并发属性遵循ConcurrentHashMap的并发属性：从get(key)返回的任何非空结果和相关的访问方法都与相关的插入或更新具有先发生关系。 任何批量操作的结果都反映了这些每元素关系的组成（但不一定是整个地图的原子，除非它以某种方式被称为静止）。 相反，因为映射中的键和值永远不为null，所以null可以作为当前缺少任何结果的可靠原子指示符。 为了维护此属性，null用作所有非标量缩减操作的隐式基础。 对于double，long和int版本，基础应该是一个，当与任何其他值组合时，返回其他值（更正式地说，它应该是减少的标识元素）。 最常见的减少具有这些特性; 例如，用基数MAX_VALUE计算基数为0或最小值的和。

    作为参数提供的搜索和转换函数应该类似地返回null以指示缺少任何结果（在这种情况下不使用它）。 在映射缩减的情况下，这也使变换能够用作过滤器，如果不应该组合元素，则返回null（或者，如果是原始特化，则返回标识基础）。 您可以在搜索或减少操作中使用它们之前，通过在“null表示现在没有任何内容”规则下自己编写复合变换和过滤来创建复合变换和过滤。

    接受和/或返回Entry参数的方法维护键值关联。 例如，当找到具有最大价值的密钥时，它们可能是有用的。 请注意，可以使用new AbstractMap.SimpleEntry(k,v)提供“plain”Entry参数。

    批量操作可能会突然完成，抛出在应用函数中遇到的异常。 在处理此类异常时请记住，其他并发执行的函数也可能抛出异常，或者如果没有发生第一个异常，则会这样做。

    与顺序形式相比，并行加速是常见的，但不能保证。 如果并行计算的基础工作比计算本身更昂贵，则涉及小地图上的简短函数的并行操作可能比顺序形式执行得更慢。 类似地，如果所有处理器忙于执行不相关的任务，则并行化可能不会导致太多实际的并行性。

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

    此类是Java Collections Framework的成员。

    从以下版本开始：
    1.5
    另请参见：
    Serialized Form

    • 构造方法摘要

      构造方法  
      构造器 描述
      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)
      使用与给定地图相同的映射创建新地图。

    • 方法摘要

      所有方法  静态方法  实例方法 具体的方法 
      变量和类型 方法 描述
      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)
      对每个条目的每个非null转换执行给定操作。
      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)
      对每个值的每个非null转换执行给定的操作。
      V get​(Object key)
      返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
      V getOrDefault​(Object key, V defaultValue)
      返回指定键映射到的值，如果此映射不包含键的映射，则返回给定的默认值。
      int hashCode()
      返回此Map的哈希码值，即映射中每个键值对的总和， key.hashCode() ^ value.hashCode() 。
      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()
      创建一个由给定类型的ConcurrentHashMap支持的新Set到Boolean.TRUE 。
      static <K> ConcurrentHashMap.KeySetView<K,​Boolean> newKeySet​(int initialCapacity)
      创建一个由ConcurrentHashMap支持的新Set ，从给定类型到Boolean.TRUE 。
      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)
      返回使用给定的reducer汇总所有（键，值）对的给定转换以组合值的结果，如果没有则返回null。
      Map.Entry<K,​V> reduceEntries​(long parallelismThreshold, BiFunction<Map.Entry<K,​V>,​Map.Entry<K,​V>,​? extends Map.Entry<K,​V>> reducer)
      返回使用给定的reducer汇总所有条目以组合值的结果，如果没有则返回null。
      <U> U reduceEntries​(long parallelismThreshold, Function<Map.Entry<K,​V>,​? extends U> transformer, BiFunction<? super U,​? super U,​? extends U> reducer)
      返回使用给定的reducer汇总所有条目的给定转换以组合值的结果，如果没有则返回null。
      double reduceEntriesToDouble​(long parallelismThreshold, ToDoubleFunction<Map.Entry<K,​V>> transformer, double basis, DoubleBinaryOperator reducer)
      返回使用给定的reducer汇总所有条目的给定转换以组合值和给定基础作为标识值的结果。
      int reduceEntriesToInt​(long parallelismThreshold, ToIntFunction<Map.Entry<K,​V>> transformer, int basis, IntBinaryOperator reducer)
      返回使用给定的reducer汇总所有条目的给定转换以组合值和给定基础作为标识值的结果。
      long reduceEntriesToLong​(long parallelismThreshold, ToLongFunction<Map.Entry<K,​V>> transformer, long basis, LongBinaryOperator reducer)
      返回使用给定的reducer汇总所有条目的给定转换以组合值和给定基础作为标识值的结果。
      K reduceKeys​(long parallelismThreshold, BiFunction<? super K,​? super K,​? extends K> reducer)
      返回使用给定的reducer汇总所有键以组合值的结果，如果没有则返回null。
      <U> U reduceKeys​(long parallelismThreshold, Function<? super K,​? extends U> transformer, BiFunction<? super U,​? super U,​? extends U> reducer)
      返回使用给定的reducer汇总所有键的给定转换以组合值的结果，如果没有则返回null。
      double reduceKeysToDouble​(long parallelismThreshold, ToDoubleFunction<? super K> transformer, double basis, DoubleBinaryOperator reducer)
      返回使用给定的reducer累加所有键的给定转换以组合值和给定的基础作为标识值的结果。
      int reduceKeysToInt​(long parallelismThreshold, ToIntFunction<? super K> transformer, int basis, IntBinaryOperator reducer)
      返回使用给定的reducer累加所有键的给定转换以组合值和给定的基础作为标识值的结果。
      long reduceKeysToLong​(long parallelismThreshold, ToLongFunction<? super K> transformer, long basis, LongBinaryOperator reducer)
      返回使用给定的reducer累加所有键的给定转换以组合值和给定的基础作为标识值的结果。
      double reduceToDouble​(long parallelismThreshold, ToDoubleBiFunction<? super K,​? super V> transformer, double basis, DoubleBinaryOperator reducer)
      返回使用给定的reducer汇总所有（键，值）对的给定转换以组合值和给定基础作为标识值的结果。
      int reduceToInt​(long parallelismThreshold, ToIntBiFunction<? super K,​? super V> transformer, int basis, IntBinaryOperator reducer)
      返回使用给定的reducer汇总所有（键，值）对的给定转换以组合值和给定基础作为标识值的结果。
      long reduceToLong​(long parallelismThreshold, ToLongBiFunction<? super K,​? super V> transformer, long basis, LongBinaryOperator reducer)
      返回使用给定的reducer汇总所有（键，值）对的给定转换以组合值和给定基础作为标识值的结果。
      V reduceValues​(long parallelismThreshold, BiFunction<? super V,​? super V,​? extends V> reducer)
      返回使用给定的reducer汇总所有值以组合值的结果，如果没有则返回null。
      <U> U reduceValues​(long parallelismThreshold, Function<? super V,​? extends U> transformer, BiFunction<? super U,​? super U,​? extends U> reducer)
      返回使用给定的reducer汇总所有值的给定转换以组合值的结果，如果没有则返回null。
      double reduceValuesToDouble​(long parallelismThreshold, ToDoubleFunction<? super V> transformer, double basis, DoubleBinaryOperator reducer)
      返回使用给定的reducer累积所有值的给定转换以组合值和给定基础作为标识值的结果。
      int reduceValuesToInt​(long parallelismThreshold, ToIntFunction<? super V> transformer, int basis, IntBinaryOperator reducer)
      返回使用给定的reducer累积所有值的给定转换以组合值和给定基础作为标识值的结果。
      long reduceValuesToLong​(long parallelismThreshold, ToLongFunction<? super V> transformer, long basis, LongBinaryOperator reducer)
      返回使用给定的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结果，如果没有则返回null。
      <U> U searchEntries​(long parallelismThreshold, Function<Map.Entry<K,​V>,​? extends U> searchFunction)
      返回在每个条目上应用给定搜索函数的非null结果，如果没有则返回null。
      <U> U searchKeys​(long parallelismThreshold, Function<? super K,​? extends U> searchFunction)
      返回在每个键上应用给定搜索函数的非null结果，如果没有则返回null。
      <U> U searchValues​(long parallelismThreshold, Function<? super V,​? extends U> searchFunction)
      返回在每个值上应用给定搜索函数的非null结果，如果没有则返回null。
      String toString()
      返回此映射的字符串表示形式。
      Collection<V> values()
      返回此映射中包含的值的Collection视图。

    • 构造方法详细信息

      • 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

      • ConcurrentHashMap

        public ConcurrentHashMap​(int initialCapacity,
                         float loadFactor,
                         int concurrencyLevel)
        创建具有基于元件（给定数量的一个初始表大小的新的空映射 initialCapacity ），初始表密度（ loadFactor ），并同时更新线程（数 concurrencyLevel ）。
        参数
        initialCapacity - 初始容量。 在给定指定的载荷因子的情况下，该实现执行内部大小调整以适应这么多元素。
        loadFactor - 用于建立初始表大小的加载因子（表密度）
        concurrencyLevel - 估计的并发更新线程数。 实现可以将此值用作大小提示。
        异常
        IllegalArgumentException - 如果初始容量为负数或负载因子或concurrencyLevel为非正数

    • 方法详细信息

      • get

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

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

        Specified by:
        get在界面 Map<K,​V>
        重写：
        get在类 AbstractMap<K,​V>
        参数
        key - 要返回其关联值的键
        结果
        指定键映射到的值，如果此映射不包含键的映射， null
        异常
        NullPointerException - 如果指定的键为空

      • containsKey

        public boolean containsKey​(Object key)
        测试指定的对象是否为此表中的键。
        Specified by:
        containsKey in interface Map<K,​V>
        重写：
        containsKey类 AbstractMap<K,​V>
        参数
        key - 可能的关键
        结果
        true当且仅当指定的对象是此表中的键时，由equals方法确定; 否则为false
        异常
        NullPointerException - 如果指定的键为空

      • containsValue

        public boolean containsValue​(Object value)
        如果此映射将一个或多个键映射到指定值，则返回true 。 注意：此方法可能需要完全遍历地图，并且比方法containsKey慢得多。
        Specified by:
        containsValue ，界面 Map<K,​V>
        重写：
        containsValue类 AbstractMap<K,​V>
        参数
        value - 要测试其在此地图中的存在的值
        结果
        true如果此映射将一个或多个键映射到指定的值
        异常
        NullPointerException - 如果指定的值为null

      • put

        public V put​(K key,
             V value)
        将指定的键映射到此表中的指定值。 密钥和值都不能为空。

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

        Specified by:
        put在界面 Map<K,​V>
        重写：
        put在 AbstractMap<K,​V>类
        参数
        key - 与指定值关联的键
        value - 与指定键关联的值
        结果
        以前的值与相关 key ，或 null如果没有映射 key
        异常
        NullPointerException - 如果指定的键或值为null

      • putAll

        public void putAll​(Map<? extends K,​? extends V> m)
        将指定映射中的所有映射复制到此映射。 这些映射将替换此映射对当前位于指定映射中的任何键的任何映射。
        Specified by:
        putAll在界面 Map<K,​V>
        重写：
        putAll在类 AbstractMap<K,​V>
        参数
        m - 要存储在此映射中的映射

      • remove

        public V remove​(Object key)
        从此映射中删除键（及其对应的值）。 如果键不在地图中，则此方法不执行任何操作。
        Specified by:
        remove在界面 Map<K,​V>
        重写：
        remove在 AbstractMap<K,​V>类
        参数
        key - 需要删除的密钥
        结果
        与 key关联的先前值，如果 null没有映射， key
        异常
        NullPointerException - 如果指定的键为空

      • clear

        public void clear()
        从此映射中删除所有映射。
        Specified by:
        clear在界面 Map<K,​V>
        重写：
        clear类 AbstractMap<K,​V>

      • values

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

        视图的迭代器和分裂器是weakly consistent 。

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

        Specified by:
        values在接口 Map<K,​V>
        重写：
        values类 AbstractMap<K,​V>
        结果
        集合视图

      • entrySet

        public Set<Map.Entry<K,​V>> entrySet()
        返回此映射中包含的映射的Set视图。 该集由地图支持，因此对地图的更改将反映在集中，反之亦然。 该组支持元件移除，即从映射中相应的映射，经由Iterator.remove ， Set.remove ， removeAll ， retainAll ，和clear操作。

        视图的迭代器和分裂器是weakly consistent 。

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

        Specified by:
        entrySet ，界面 Map<K,​V>
        结果
        设定视图

      • toString

        public String toString()
        返回此映射的字符串表示形式。 字符串表示由括在括号（“ {} ”）中的键值映射列表（无特定顺序）组成。 相邻映射由字符", " （逗号和空格）分隔。 每个键值映射都呈现为键，后跟等号（“ = ”），后跟相关值。
        重写：
        toString在类 AbstractMap<K,​V>
        结果
        此映射的字符串表示形式

      • equals

        public boolean equals​(Object o)
        将指定对象与此映射进行比较以获得相等性。 如果给定对象是具有与此映射相同映射的映射，则返回true 。 如果在执行此方法期间同时修改了任一映射，则此操作可能会返回误导性结果。
        Specified by:
        equals ，界面 Map<K,​V>
        重写：
        equals在类 AbstractMap<K,​V>
        参数
        o - 要与此映射进行相等性比较的对象
        结果
        true如果指定的对象等于此映射
        另请参见：
        Object.hashCode() ， HashMap

      • putIfAbsent

        public V putIfAbsent​(K key,
                     V value)
        如果指定的键尚未与值关联，请将其与给定值相关联。 这相当于，对于这个map ： 
           if (!map.containsKey(key)) return map.put(key, value); else return map.get(key);
        除了动作以原子方式执行。
        Specified by:
        putIfAbsent ，界面 ConcurrentMap<K,​V>
        Specified by:
        putIfAbsent在界面 Map<K,​V>
        参数
        key - 与指定值关联的键
        value - 与指定密钥关联的值
        结果
        与指定键关联的先前值，如果没有键的映射， null
        异常
        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 in interface ConcurrentMap<K,​V>
        Specified by:
        remove ，界面 Map<K,​V>
        参数
        key - 与指定值关联的键
        value - 期望与指定密钥关联的值
        结果
        true如果删除了该值
        异常
        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如果值已被替换
        异常
        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
        异常
        NullPointerException - 如果指定的键或值为null

      • getOrDefault

        public V getOrDefault​(Object key,
                      V defaultValue)
        返回指定键映射到的值，如果此映射不包含键的映射，则返回给定的默认值。
        Specified by:
        getOrDefault in interface ConcurrentMap<K,​V>
        Specified by:
        getOrDefault在界面 Map<K,​V>
        参数
        key - 要返回其关联值的密钥
        defaultValue - 如果此映射不包含给定键的映射，则返回的值
        结果
        密钥的映射（如果存在）; 否则是默认值
        异常
        NullPointerException - 如果指定的键为空

      • 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 - 如果指定的键或mappingFunction为null
        IllegalStateException - 如果计算可检测地尝试递归更新此映射，否则将永远不会完成
        RuntimeException - 或者如果mappingFunction这样做会出错，在这种情况下，映射将保持不变

      • 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 - 如果指定的键或 NullPointerException为null
        IllegalStateException - 如果计算可检测地尝试递归更新此映射，否则将永远不会完成
        RuntimeException - 或者如果 RuntimeException这样做会出错，在这种情况下映射不变

      • compute

        public V compute​(K key,
                 BiFunction<? super K,​? super V,​? extends V> remappingFunction)
        尝试计算指定键及其当前映射值的映射（如果没有当前映射， null ）。 整个方法调用以原子方式执行。 其他线程在此映射上的某些尝试更新操作可能在计算进行时被阻止，因此计算应该简短，并且不得尝试更新此Map的任何其他映射。
        Specified by:
        compute ，界面 ConcurrentMap<K,​V>
        Specified by:
        compute在界面 Map<K,​V>
        参数
        key - 与指定值关联的键
        remappingFunction - 计算值的函数
        结果
        与指定键关联的新值，如果没有，则返回null
        异常
        NullPointerException - 如果指定的键或 NullPointerException为null
        IllegalStateException - 如果计算可检测地尝试递归更新此映射，否则将永远不会完成
        RuntimeException - 如果 RuntimeException这样做则出错，在这种情况下映射不变

      • merge

        public V merge​(K key,
               V value,
               BiFunction<? super V,​? super V,​? extends V> remappingFunction)
        如果指定的键尚未与（非空）值关联，则将其与给定值相关联。 否则，将值替换为给定重映射函数的结果，或者删除null 。 整个方法调用以原子方式执行。 其他线程在此映射上的某些尝试更新操作可能在计算进行时被阻止，因此计算应该简短，并且不得尝试更新此Map的任何其他映射。
        Specified by:
        merge在界面 ConcurrentMap<K,​V>
        Specified by:
        merge在界面 Map<K,​V>
        参数
        key - 与指定值关联的键
        value - 缺席时使用的值
        remappingFunction - 重新计算值的函数（如果存在）
        结果
        与指定键关联的新值，如果没有，则返回null
        异常
        NullPointerException - 如果指定的键或 NullPointerException为null
        RuntimeException - 或者如果 RuntimeException这样做会出错，在这种情况下映射不变

      • contains

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

        请注意，此方法在功能上与containsValue(Object)完全相同 ，并且仅用于确保与Hashtable完全兼容，类Hashtable在引入Java Collections Framework之前支持此方法。

        参数
        value - 要搜索的值
        结果
        true当且仅当某个键映射到此表中的value参数时，由equals方法确定; 否则为false
        异常
        NullPointerException - 如果指定的值为null

      • keys

        public Enumeration<K> keys()
        返回此表中键的枚举。
        结果
        此表中键的枚举
        另请参见：
        keySet()

      • elements

        public Enumeration<V> elements()
        返回此表中值的枚举。
        结果
        此表中的值的枚举
        另请参见：
        values()

      • mappingCount

        public long mappingCount()
        返回映射的数量。 应该使用此方法而不是Map.size()，因为ConcurrentHashMap可能包含的映射数多于可以表示为int的映射。 返回的值是估计值; 如果同时插入或删除，实际计数可能会有所不同。
        结果
        映射的数量
        从以下版本开始：
        1.8

      • newKeySet

        public static <K> ConcurrentHashMap.KeySetView<K,​Boolean> newKeySet()
        创建一个由ConcurrentHashMap支持的新Set ，从给定类型到Boolean.TRUE 。
        参数类型
        K - 返回集的元素类型
        结果
        新集
        从以下版本开始：
        1.8

      • newKeySet

        public static <K> ConcurrentHashMap.KeySetView<K,​Boolean> newKeySet​(int initialCapacity)
        创建一个由给定类型的ConcurrentHashMap支持的新Set到Boolean.TRUE 。
        参数类型
        K - 返回集的元素类型
        参数
        initialCapacity - 实现执行内部大小调整以适应这么多元素。
        结果
        新集
        异常
        IllegalArgumentException - 如果元素的初始容量为负数
        从以下版本开始：
        1.8

      • forEach

        public void forEach​(long parallelismThreshold,
                    BiConsumer<? super K,​? super V> action)
        对每个（键，值）执行给定的操作。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        action - 动作
        从以下版本开始：
        1.8

      • forEach

        public <U> void forEach​(long parallelismThreshold,
                        BiFunction<? super K,​? super V,​? extends U> transformer,
                        Consumer<? super U> action)
        对每个（键，值）的每个非空转换执行给定的操作。
        参数类型
        U - U的返回类型
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数，如果没有转换则返回null（在这种情况下不应用操作）
        action - 动作
        从以下版本开始：
        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

      • reduce

        public <U> U reduce​(long parallelismThreshold,
                    BiFunction<? super K,​? super V,​? extends U> transformer,
                    BiFunction<? super U,​? super U,​? extends U> reducer)
        返回使用给定的reducer汇总所有（键，值）对的给定转换以组合值的结果，如果没有则返回null。
        参数类型
        U - U的返回类型
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数，如果没有转换则返回null（在这种情况下不合并）
        reducer - 交换关联组合函数
        结果
        累积所有（键，值）对的给定变换的结果
        从以下版本开始：
        1.8

      • reduceToDouble

        public double reduceToDouble​(long parallelismThreshold,
                             ToDoubleBiFunction<? super K,​? super V> transformer,
                             double basis,
                             DoubleBinaryOperator reducer)
        返回使用给定的reducer汇总所有（键，值）对的给定转换以组合值和给定基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 交换关联组合函数
        结果
        累积所有（键，值）对的给定变换的结果
        从以下版本开始：
        1.8

      • reduceToLong

        public long reduceToLong​(long parallelismThreshold,
                         ToLongBiFunction<? super K,​? super V> transformer,
                         long basis,
                         LongBinaryOperator reducer)
        返回使用给定的reducer汇总所有（键，值）对的给定转换以组合值和给定基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 交换关联组合函数
        结果
        累积所有（键，值）对的给定变换的结果
        从以下版本开始：
        1.8

      • reduceToInt

        public int reduceToInt​(long parallelismThreshold,
                       ToIntBiFunction<? super K,​? super V> transformer,
                       int basis,
                       IntBinaryOperator reducer)
        返回使用给定的reducer汇总所有（键，值）对的给定转换以组合值和给定基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 可交换的关联组合函数
        结果
        累积所有（键，值）对的给定变换的结果
        从以下版本开始：
        1.8

      • forEachKey

        public void forEachKey​(long parallelismThreshold,
                       Consumer<? super K> action)
        对每个键执行给定的操作。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        action - 动作
        从以下版本开始：
        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

      • searchKeys

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

      • reduceKeys

        public K reduceKeys​(long parallelismThreshold,
                    BiFunction<? super K,​? super K,​? extends K> reducer)
        返回使用给定的reducer汇总所有键以组合值的结果，如果没有则返回null。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        reducer - 交换关联组合函数
        结果
        使用给定的reducer汇总所有键以组合值的结果，如果没有则为null
        从以下版本开始：
        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 - 返回元素转换的函数，如果没有转换则返回null（在这种情况下不合并）
        reducer - 交换关联组合函数
        结果
        累积所有键的给定转换的结果
        从以下版本开始：
        1.8

      • reduceKeysToDouble

        public double reduceKeysToDouble​(long parallelismThreshold,
                                 ToDoubleFunction<? super K> transformer,
                                 double basis,
                                 DoubleBinaryOperator reducer)
        返回使用给定的reducer累加所有键的给定转换以组合值和给定的基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - 减少的标识（初始缺省值）
        reducer - 可交换的关联组合函数
        结果
        累积所有键的给定转换的结果
        从以下版本开始：
        1.8

      • reduceKeysToLong

        public long reduceKeysToLong​(long parallelismThreshold,
                             ToLongFunction<? super K> transformer,
                             long basis,
                             LongBinaryOperator reducer)
        返回使用给定的reducer累加所有键的给定转换以组合值和给定的基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 一个可交换的关联组合函数
        结果
        累积所有键的给定转换的结果
        从以下版本开始：
        1.8

      • reduceKeysToInt

        public int reduceKeysToInt​(long parallelismThreshold,
                           ToIntFunction<? super K> transformer,
                           int basis,
                           IntBinaryOperator reducer)
        返回使用给定的reducer累加所有键的给定转换以组合值和给定的基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 交换关联组合函数
        结果
        累积所有键的给定转换的结果
        从以下版本开始：
        1.8

      • forEachValue

        public void forEachValue​(long parallelismThreshold,
                         Consumer<? super V> action)
        对每个值执行给定的操作。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        action - 动作
        从以下版本开始：
        1.8

      • forEachValue

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

      • searchValues

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

      • reduceValues

        public V reduceValues​(long parallelismThreshold,
                      BiFunction<? super V,​? super V,​? extends V> reducer)
        返回使用给定的reducer汇总所有值以组合值的结果，如果没有则返回null。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        reducer - 交换关联组合函数
        结果
        累积所有值的结果
        从以下版本开始：
        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 - 返回元素转换的函数，如果没有转换则返回null（在这种情况下不合并）
        reducer - 交换关联组合函数
        结果
        累积所有值的给定转换的结果
        从以下版本开始：
        1.8

      • reduceValuesToDouble

        public double reduceValuesToDouble​(long parallelismThreshold,
                                   ToDoubleFunction<? super V> transformer,
                                   double basis,
                                   DoubleBinaryOperator reducer)
        返回使用给定的reducer累积所有值的给定转换以组合值和给定基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 可交换的关联组合函数
        结果
        累积所有值的给定转换的结果
        从以下版本开始：
        1.8

      • reduceValuesToLong

        public long reduceValuesToLong​(long parallelismThreshold,
                               ToLongFunction<? super V> transformer,
                               long basis,
                               LongBinaryOperator reducer)
        返回使用给定的reducer累积所有值的给定转换以组合值和给定基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 交换关联组合函数
        结果
        累积所有值的给定转换的结果
        从以下版本开始：
        1.8

      • reduceValuesToInt

        public int reduceValuesToInt​(long parallelismThreshold,
                             ToIntFunction<? super V> transformer,
                             int basis,
                             IntBinaryOperator reducer)
        返回使用给定的reducer累积所有值的给定转换以组合值和给定基础作为标识值的结果。
        参数
        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)
        对每个条目的每个非null转换执行给定操作。
        参数类型
        U - 变压器的返回类型
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数，如果没有转换则返回null（在这种情况下不应用操作）
        action - 动作
        从以下版本开始：
        1.8

      • searchEntries

        public <U> U searchEntries​(long parallelismThreshold,
                           Function<Map.Entry<K,​V>,​? extends U> searchFunction)
        返回在每个条目上应用给定搜索函数的非null结果，如果没有则返回null。 成功后，将抑制进一步的元素处理，并忽略搜索功能的任何其他并行调用的结果。
        参数类型
        U - 搜索功能的返回类型
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        searchFunction - 一个函数在成功时返回非null结果，否则为null
        结果
        在每个条目上应用给定搜索函数的非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 - 交换关联组合函数
        结果
        累积所有条目的给定转换的结果
        从以下版本开始：
        1.8

      • reduceEntriesToDouble

        public double reduceEntriesToDouble​(long parallelismThreshold,
                                    ToDoubleFunction<Map.Entry<K,​V>> transformer,
                                    double basis,
                                    DoubleBinaryOperator reducer)
        返回使用给定的reducer汇总所有条目的给定转换以组合值和给定基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 交换关联组合函数
        结果
        累积所有条目的给定转换的结果
        从以下版本开始：
        1.8

      • reduceEntriesToLong

        public long reduceEntriesToLong​(long parallelismThreshold,
                                ToLongFunction<Map.Entry<K,​V>> transformer,
                                long basis,
                                LongBinaryOperator reducer)
        返回使用给定的reducer汇总所有条目的给定转换以组合值和给定基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 交换关联组合函数
        结果
        累积所有条目的给定转换的结果
        从以下版本开始：
        1.8

      • reduceEntriesToInt

        public int reduceEntriesToInt​(long parallelismThreshold,
                              ToIntFunction<Map.Entry<K,​V>> transformer,
                              int basis,
                              IntBinaryOperator reducer)
        返回使用给定的reducer汇总所有条目的给定转换以组合值和给定基础作为标识值的结果。
        参数
        parallelismThreshold - 并行执行此操作所需的（估计）元素数
        transformer - 返回元素转换的函数
        basis - basis的标识（初始默认值）
        reducer - 可交换的关联组合函数
        结果
        累积所有条目的给定转换的结果
        从以下版本开始：
        1.8