Module  java.base
软件包  java.util.concurrent

Class ConcurrentHashMap<K,V>

  • 参数类型
    K - 由该地图维护的键的类型
    V - 映射值的类型
    All Implemented Interfaces:
    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 ，并发检索可能反映插入或移除只有一些条目。 类似地，迭代器，分割器和枚举返回在反映迭代器/枚举创建过程中或之后反映哈希表状态的元素。 他们不抛出ConcurrentModificationException 。 然而，迭代器被设计为一次只能由一个线程使用。 请记住，骨料状态方法的结果，包括size ， isEmpty ，并containsValue通常是有用的，只有当一个地图没有发生在其他线程并发更新。 否则，这些方法的结果反映了可能足以用于监视或估计目的的瞬态状态，但不适用于程序控制。

    当存在太多的冲突（即，具有不同的哈希码但是以表的大小为模数落入相同的时隙的密钥）时，该表被动态扩展，并且每个映射保持大致两个bin的预期平均效果（对应于0.75负载调整大小的因子阈值）。 这个平均值可能会有很多变化，因为映射被添加和删除，但是总的来说，这为哈希表保留了普遍接受的时间/空间权衡。 然而，调整这个或任何其他类型的散列表可能是相对较慢的操作。 如果可能，最好提供一个大小估计作为可选的initialCapacity构造函数参数。 附加的可选的loadFactor构造函数参数提供了通过指定在计算给定数量的元素时要分配的空间量而使用的表密度来定制初始表容量的另一种方法。 此外，为了与此类的以前版本兼容，构造函数可以可选地指定预期的concurrencyLevel作为内部大小调整的附加提示。 请注意，使用完全相同的许多键hashCode()是降低任何哈希表的性能的一种可靠的方法。 为了改善影响，当按键为Comparable时 ，该类可以使用键之间的比较顺序来帮助打破关系。

    甲Set投影一个的ConcurrentHashMap可以（使用被创建newKeySet()或newKeySet(int) ），或观察（使用keySet(Object)时仅键是感兴趣的，并且被映射的值是（可能瞬时）不使用或全部取相同的映射值。

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

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

    像Hashtable但不像HashMap ，此类不允许 null用作键或值。

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

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

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

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

    作为参数提供的搜索和转换函数应该类似地返回null以指示缺少任何结果（在这种情况下不被使用）。 在映射缩减的情况下，这也使得转换可以用作过滤器，如果不应该组合元素，返回null（或者在原始专业化的情况下，身份基础）。 在使用它们进行搜索或减少操作之前，您可以通过在“null意味着现在没有任何内容”规则下自行构建复合转换和过滤。

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

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

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

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

    这个类是Java Collections Framework的成员。

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

    • 构造方法摘要

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

    • 方法摘要

      所有方法  静态方法  接口方法  具体的方法 
      Modifier and Type 方法 描述
      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)
      对每个（key，value）的每个非空变换执行给定的动作。
      void forEach​(BiConsumer<? super K,? super V> 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)
      使用给定的公共映射值为任何添加（即Collection.add(E)和Collection.addAll(Collection) ）返回此映射中的密钥的Set视图。
      long mappingCount​()
      返回映射数。
      V merge​(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
      如果指定的键尚未与（非空）值相关联，则将其与给定值相关联。
      static <K> ConcurrentHashMap.KeySetView<K,Boolean> newKeySet​()
      创建一个新的Set支持的ConcurrentHashMap从给定的类型到Boolean.TRUE 。
      static <K> ConcurrentHashMap.KeySetView<K,Boolean> newKeySet​(int initialCapacity)
      创建一个新的Set支持的ConcurrentHashMap从给定的类型到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将所有（key，value）对的给定变换累加到组合值的结果，如果没有则返回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将所有（key，value）对的给定变换累加到结合值的结果，给定基础作为标识值。
      int reduceToInt​(long parallelismThreshold, ToIntBiFunction<? super K,? super V> transformer, int basis, IntBinaryOperator reducer)
      返回使用给定的reducer将所有（key，value）对的给定变换累加到结合值的结果，给定基础作为标识值。
      long reduceToLong​(long parallelismThreshold, ToLongBiFunction<? super K,? super V> transformer, long basis, LongBinaryOperator reducer)
      返回使用给定的reducer将所有（key，value）对的给定变换累加到结合值的结果，给定基础作为标识值。
      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)
      仅当当前映射到给定值时才替换密钥的条目。
      void replaceAll​(BiFunction<? super K,? super V,? extends V> function)
      将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
      <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视图。

    • 构造方法详细信息

      • 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 - 如果初始容量为负值或负载因子或并发 IllegalArgumentException为非正性

    • 方法详细信息

      • size

        public int size​()
        返回此地图中键值映射的数量。 如果地图包含Integer.MAX_VALUE元素，返回Integer.MAX_VALUE 。
        Specified by:
        size接口 Map<K,V>
        重写：
        size中的 AbstractMap<K,V>
        结果
        该地图中键值映射的数量

      • isEmpty

        public boolean isEmpty​()
        如果此映射不包含键值映射，则返回 true 。
        Specified by:
        isEmpty在接口 Map<K,V>
        重写：
        isEmpty中的 AbstractMap<K,V>
        结果
        true如果该地图不包含键值映射

      • 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在接口 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 - 如果指定的值为空

      • 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 - 如果指定的键或值为空

      • 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>
        结果
        集合视图

      • 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 - 如果指定的键或值为空

      • 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; }
        除了动作以原子方式执行。
        Specified by:
        remove在接口 ConcurrentMap<K,V>
        Specified by:
        remove在接口 Map<K,V>
        参数
        key - 与指定值相关联的键
        value - 预期与指定键相关联的值
        结果
        true如果该值被删除
        异常
        NullPointerException - 如果指定的键为空

      • replace

        public boolean replace​(K key,
                       V oldValue,
                       V newValue)
        仅当当前映射到给定值时才替换密钥的条目。 这相当于，对于这个map ： 
           if (map.containsKey(key) && Objects.equals(map.get(key), oldValue)) { map.put(key, newValue); return true; } else { return false; }
        除了动作以原子方式执行。
        Specified by:
        replace在接口 ConcurrentMap<K,V>
        Specified by:
        replace在接口 Map<K,V>
        参数
        key - 与指定值相关联的键
        oldValue - 预期与指定键相关联的值
        newValue - 与指定键相关联的值
        结果
        true如果值被替换
        异常
        NullPointerException - 如果任何参数为空

      • replace

        public V replace​(K key,
                 V value)
        仅当当前映射到某个值时才替换该项的条目。 这相当于，对于这个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 - 如果指定的键或值为空

      • getOrDefault

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

      • forEach

        public void forEach​(BiConsumer<? super K,? super V> action)
        描述从接口ConcurrentMap复制
        对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。 除非实现类另有指定，否则按照进入设置迭代的顺序执行操作（如果指定了迭代顺序）。操作引发的异常被转发给调用者。
        Specified by:
        forEach接口 ConcurrentMap<K,V>
        Specified by:
        forEach接口 Map<K,V>
        参数
        action - 要为每个条目执行的操作

      • replaceAll

        public void replaceAll​(BiFunction<? super K,? super V,? extends V> function)
        说明从界面ConcurrentMap复制
        将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。 函数抛出的异常被转发给调用方。
        Specified by:
        replaceAll接口 ConcurrentMap<K,V>
        Specified by:
        replaceAll在接口 Map<K,V>
        参数
        function - 应用于每个条目的功能

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

      • merge

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

      • contains

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

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

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

      • keys

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

      • elements

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

      • mappingCount

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

      • newKeySet

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

      • newKeySet

        public static <K> ConcurrentHashMap.KeySetView<K,Boolean> newKeySet​(int initialCapacity)
        创建一个新的Set由ConcurrentHashMap从给定类型支持到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)
        对每个（key，value）的每个非空变换执行给定的动作。
        参数类型
        U - 变压器的返回类型
        参数
        parallelismThreshold - 并行执行此操作所需的元素数量（估计）
        transformer - 返回元素的变换的函数，如果没有变换，则返回null（在这种情况下不应用动作）
        action - 行动
        从以下版本开始：
        1.8

      • search

        public <U> U search​(long parallelismThreshold,
                    BiFunction<? super K,? super V,? extends U> searchFunction)
        通过在每个（键，值）上应用给定的搜索函数返回非空结果，如果没有则返回null。 成功后，进一步的元素处理被抑制，并且搜索功能的任何其他并行调用的结果被忽略。
        参数类型
        U - 搜索功能的返回类型
        参数
        parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
        searchFunction - 成功返回非空结果的函数，否则为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将所有（key，value）对的给定变换累加到组合值的结果，如果没有则返回null。
        参数类型
        U - 变压器的返回类型
        参数
        parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
        transformer - 一个返回元素的变换的函数，如果没有转换，则返回null（在这种情况下不进行组合）
        reducer - 一种交换联想组合函数
        结果
        所有（键，值）对的累加给定变换的结果
        从以下版本开始：
        1.8

      • reduceToDouble

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

      • reduceToLong

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

      • reduceToInt

        public int reduceToInt​(long parallelismThreshold,
                       ToIntBiFunction<? super K,? super V> transformer,
                       int basis,
                       IntBinaryOperator reducer)
        返回使用给定的reducer将所有（key，value）对的给定变换累加到结合值的结果，给定基础作为标识值。
        参数
        parallelismThreshold - 并行执行此操作所需的元素数量（估计）
        transformer - 返回元素变换的函数
        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。 成功后，进一步的元素处理被抑制，并且搜索功能的任何其他并行调用的结果被忽略。
        参数类型
        U - 搜索功能的返回类型
        参数
        parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
        searchFunction - 成功返回非空结果的函数，否则为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 - 减少的身份（初始默认值）
        reducer - 交换联想组合函数
        结果
        积累所有键的给定变换的结果
        从以下版本开始：
        1.8

      • reduceKeysToInt

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

      • searchValues

        public <U> U searchValues​(long parallelismThreshold,
                          Function<? super V,? extends U> searchFunction)
        返回一个非空结果，对每个值应用给定的搜索函数，如果没有，返回null。 成功后，进一步的元素处理被抑制，并且搜索功能的任何其他并行调用的结果被忽略。
        参数类型
        U - 搜索功能的返回类型
        参数
        parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
        searchFunction - 成功返回非空结果的函数，否则为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 - 减少的身份（初始默认值）
        reducer - 交换联想组合函数
        结果
        积累所有值的给定变换的结果
        从以下版本开始：
        1.8

      • reduceValuesToLong

        public long reduceValuesToLong​(long parallelismThreshold,
                               ToLongFunction<? super V> transformer,
                               long basis,
                               LongBinaryOperator reducer)
        返回使用给定的reducer累加所有值的给定变换的结果，以组合值，给定基础作为标识值。
        参数
        parallelismThreshold - 并行执行此操作所需的元素数量（估计）
        transformer - 返回元素变换的函数
        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)
        对每个条目的每个非空变换执行给定的操作。
        参数类型
        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 - 交换联想组合函数
        结果
        累积所有条目的给定转换的结果
        从以下版本开始：
        1.8

      • reduceEntriesToDouble

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

      • reduceEntriesToLong

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

      • reduceEntriesToInt

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