java.lang.Object

java.util.concurrent.ConcurrentHashMap<K,V>

类型参数：: K - 此map维护的键类型; V - 映射值的类型

所有已实现的接口：: Serializable , ConcurrentMap<K,V> , Map<K,V>

public class ConcurrentHashMap<K,V> extends AbstractMap <K,V> implements ConcurrentMap <K,V>, Serializable

一个哈希表，支持检索的完全并发和更新的高预期并发。此类遵循与 Hashtable 相同的功能规范，并包含与 Hashtable 的每个方法对应的方法版本。然而，即使所有操作都是线程安全的，检索操作确实not需要锁定，并且not任何支持以防止所有访问的方式锁定整个表。在依赖线程安全而非同步细节的程序中，此类与 Hashtable 完全可互操作。

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

当有太多冲突时，该表会动态扩展（即，具有不同哈希码但以表大小为模的键落入同一插槽），预期平均效果是每个映射保持大约两个 bin（对应于 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 接口的所有 optional 方法。

与 Hashtable 相似但与 HashMap 不同，此类确实 not 允许 null 用作键或值。

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

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

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

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

作为参数提供的搜索和转换函数应该类似地返回 null 以指示缺少任何结果（在这种情况下不使用它）。在映射缩减的情况下，这也使转换能够充当过滤器，如果不应组合元素，则返回 null（或者，在原始特化的情况下，返回身份基础）。在将它们用于搜索或归约操作之前，您可以根据“null 意味着现在什么都没有”规则自己组合它们来创建复合转换和过滤。

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

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

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

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

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

自从：

1.5

参见：

Serialized Form

内部类总结

内部类

修饰符和类型

类

描述

static class

ConcurrentHashMap.KeySetView<K,V>

将 ConcurrentHashMap 视为键的 Set 视图，其中可以通过映射到公共值来选择性地启用添加。

在类 java.util.AbstractMap 中声明的嵌套类/接口
AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>

在接口 java.util.Map 中声明的嵌套类/接口
Map.Entry<K,V>
构造方法总结

构造方法

构造方法

描述

ConcurrentHashMap()

使用默认的初始表大小 (16) 创建一个新的空map。

ConcurrentHashMap(int initialCapacity)

创建一个新的空map，其初始表大小可容纳指定数量的元素，而无需动态调整大小。

ConcurrentHashMap(int initialCapacity, float loadFactor)

根据给定的元素数量 (initialCapacity) 和初始表密度 (loadFactor) 创建一个具有初始表大小的新空映射。

ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)

根据给定的元素数 (initialCapacity)、初始表密度 (loadFactor) 和并发更新线程数 (concurrencyLevel) 创建一个具有初始表大小的新空映射。

ConcurrentHashMap(Map<? extends K,? extends V> m)

创建一个与给定map具有相同映射关系的新map。
方法总结

修饰符和类型

方法

描述

void

clear()

从此map中删除所有映射。

V

compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)

尝试计算指定键及其当前映射值的映射（如果没有当前映射，则为 null）。

V

computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)

如果指定的键尚未与值关联，则尝试使用给定的映射函数计算其值并将其输入到此map中，除非 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)

如果此map将一个或多个键映射到指定值，则返回 true。

Enumeration<V>

elements()

返回此表中值的枚举。

Set<Map.Entry<K,V>>

entrySet()

返回此map中包含的映射的 Set 视图。

boolean

equals(Object o)

比较指定对象与此map是否相等。

void

forEach(long parallelismThreshold, BiConsumer<? super K,? super V> action)

对每个（键，值）执行给定的操作。

 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)

对每个条目执行给定的操作。

 void

forEachEntry(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> transformer, Consumer<? super U> action)

对每个条目的每个非空转换执行给定的操作。

void

forEachKey(long parallelismThreshold, Consumer<? super K> action)

对每个键执行给定的操作。

 void

forEachKey(long parallelismThreshold, Function<? super K,? extends U> transformer, Consumer<? super U> action)

对每个键的每个非空转换执行给定的操作。

void

forEachValue(long parallelismThreshold, Consumer<? super V> action)

对每个值执行给定的操作。

 void

forEachValue(long parallelismThreshold, Function<? super V,? extends U> transformer, Consumer<? super U> action)

对每个值的每个非空转换执行给定的操作。

V

get(Object key)

返回指定键映射到的值，如果此map不包含键的映射，则返回 null。

V

getOrDefault(Object key, V defaultValue)

返回指定键映射到的值，如果此map不包含键的映射，则返回给定的默认值。

int

hashCode()

返回此 Map 的哈希码值，即map中每个键值对的哈希码值 key.hashCode() ^ value.hashCode() 的总和。

boolean

isEmpty()

如果此map不包含键值映射，则返回 true。

Enumeration<K>

keys()

返回此表中键的枚举。

ConcurrentHashMap.KeySetView<K,V>

keySet()

返回此map中包含的键的 Set 视图。

ConcurrentHashMap.KeySetView<K,V>

keySet(V mappedValue)

返回此map中键的 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()

创建一个新的 Set ，由从给定类型到 Boolean.TRUE 的 ConcurrentHashMap 支持。

static <K> ConcurrentHashMap.KeySetView<K,Boolean>

newKeySet(int initialCapacity)

创建一个新的 Set ，由从给定类型到 Boolean.TRUE 的 ConcurrentHashMap 支持。

V

put(K key, V value)

将指定键映射到此表中的指定值。

void

putAll(Map<? extends K,? extends V> m)

将指定map中的所有映射复制到此map。

V

putIfAbsent(K key, V value)

如果指定的键尚未与值关联，则将其与给定值关联。

 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

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)

返回使用给定的缩减器累积所有键以组合值的结果，如果没有则返回 null。

 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

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)

从此map中删除键（及其对应的值）。

boolean

remove(Object key, Object value)

仅当当前映射到给定值时才删除键的条目。

V

replace(K key, V value)

仅当当前映射到某个值时才替换键的条目。

boolean

replace(K key, V oldValue, V newValue)

仅当当前映射到给定值时才替换键的条目。

 U

search(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> searchFunction)

通过对每个 (key, value) 应用给定的搜索函数返回一个非空结果，如果没有则返回 null。

 U

searchEntries(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> searchFunction)

通过在每个条目上应用给定的搜索函数返回非空结果，如果没有则返回空。

 U

searchKeys(long parallelismThreshold, Function<? super K,? extends U> searchFunction)

通过在每个键上应用给定的搜索函数返回非空结果，如果没有则返回空。

 U

searchValues(long parallelismThreshold, Function<? super V,? extends U> searchFunction)

通过对每个值应用给定的搜索函数返回非空结果，如果没有则返回空。

int

size()

返回此map中键值映射的数量。

String

toString()

返回此map的字符串表示形式。

Collection<V>

values()

返回此map中包含的值的 Collection 视图。

在类 java.util.AbstractMap 中声明的方法
clone, isEmpty, size

在类 java.lang.Object 中声明的方法
finalize, getClass, notify, notifyAll, wait, wait, wait

在接口 java.util.concurrent.ConcurrentMap 中声明的方法
forEach, replaceAll

构造方法详细信息
- ConcurrentHashMap
 
 public ConcurrentHashMap()
 
 使用默认的初始表大小 (16) 创建一个新的空map。
- ConcurrentHashMap
 
 public ConcurrentHashMap(int initialCapacity)
 
 创建一个新的空map，其初始表大小可容纳指定数量的元素，而无需动态调整大小。
 
 参数：
 
 initialCapacity - 该实现执行内部大小调整以容纳这么多元素。
 
 抛出：
 
 IllegalArgumentException - 如果元素的初始容量为负
- ConcurrentHashMap
 
 public ConcurrentHashMap(Map <? extends K ,? extends V > m)
 
 创建一个与给定map具有相同映射关系的新map。
 
 参数：
 
 m - map
- 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 - 如果初始容量为负或者负载因子或并发级别为非正
方法详情
- size
 
 public int size()
 
 返回此map中键值映射的数量。如果map包含超过 Integer.MAX_VALUE 个元素，则返回 Integer.MAX_VALUE 。
 
 指定者：
 
 size 在接口 Map<K,V> 中
 
 重写：
 
 size 在类 AbstractMap<K,V> 中
 
 返回：
 
 此map中键值映射的数量
- isEmpty
 
 public boolean isEmpty()
 
 如果此map不包含键值映射，则返回 true。
 
 指定者：
 
 isEmpty 在接口 Map<K,V> 中
 
 重写：
 
 isEmpty 在类 AbstractMap<K,V> 中
 
 返回：
 
 true 如果此map不包含键值映射
- get
 
 public V get(Object key)
 
 返回指定键映射到的值，如果此map不包含键的映射，则返回 null。
 更正式地说，如果此map包含从键 k 到值 v 的映射，使得 key.equals(k) ，则此方法返回 v ；否则返回 null 。（最多可以有一个这样的映射。）
 
 指定者：
 
 get 在接口 Map<K,V> 中
 
 重写：
 
 get 在类 AbstractMap<K,V> 中
 
 参数：
 
 key - 要返回其关联值的键
 
 返回：
 
 指定键映射到的值，如果此map不包含键的映射，则返回 null
 
 抛出：
 
 NullPointerException - 如果指定的键为空
- containsKey
 
 public boolean containsKey(Object key)
 
 测试指定对象是否是该表中的键。
 
 指定者：
 
 containsKey 在接口 Map<K,V> 中
 
 重写：
 
 containsKey 在类 AbstractMap<K,V> 中
 
 参数：
 
 key - 可能的关键
 
 返回：
 
 true 当且仅当指定对象是此表中的键时，由 equals 方法确定； false否则
 
 抛出：
 
 NullPointerException - 如果指定的键为空
- containsValue
 
 public boolean containsValue(Object value)
 
 如果此map将一个或多个键映射到指定值，则返回 true。注意：此方法可能需要完整遍历map，并且比方法 containsKey 慢得多。
 
 指定者：
 
 containsValue 在接口 Map<K,V> 中
 
 重写：
 
 containsValue 在类 AbstractMap<K,V> 中
 
 参数：
 
 value - 要测试其在此map中是否存在的值
 
 返回：
 
 true 如果此map将一个或多个键映射到指定值
 
 抛出：
 
 NullPointerException - 如果指定值为空
- put
 
 public V put(K key, V value)
 
 将指定键映射到此表中的指定值。键和值都不能为空。
 可以通过使用与原始键相同的键调用 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)
 
 将指定map中的所有映射复制到此map。这些映射替换了此map对指定map中当前任何键的任何映射。
 
 指定者：
 
 putAll 在接口 Map<K,V> 中
 
 重写：
 
 putAll 在类 AbstractMap<K,V> 中
 
 参数：
 
 m - 要存储在此map中的映射
- remove
 
 public V remove(Object key)
 
 从此map中删除键（及其对应的值）。如果键不在map中，则此方法不执行任何操作。
 
 指定者：
 
 remove 在接口 Map<K,V> 中
 
 重写：
 
 remove 在类 AbstractMap<K,V> 中
 
 参数：
 
 key - 需要删除的密钥
 
 返回：
 
 与 key 关联的先前值，如果没有 key 的映射，则为 null
 
 抛出：
 
 NullPointerException - 如果指定的键为空
- clear
 
 public void clear()
 
 从此map中删除所有映射。
 
 指定者：
 
 clear 在接口 Map<K,V> 中
 
 重写：
 
 clear 在类 AbstractMap<K,V> 中
- keySet
 
 public ConcurrentHashMap.KeySetView <K ,V > keySet()
 
 返回此map中包含的键的 Set 视图。该集合由map支持，因此对map的更改会反映在集合中，反之亦然。该集合支持元素删除，即通过 Iterator.remove 、 Set.remove 、 removeAll 、 retainAll 和 clear 操作从该map中删除相应的映射。它不支持 add 或 addAll 操作。
 视图的迭代器和拆分器是 弱一致 。
 
 视图的 spliterator 报告 Spliterator.CONCURRENT 、 Spliterator.DISTINCT 和 Spliterator.NONNULL 。
 
 指定者：
 
 keySet 在接口 Map<K,V> 中
 
 重写：
 
 keySet 在类 AbstractMap<K,V> 中
 
 返回：
 
 集合视图
- values
 
 public Collection <V > values()
 
 返回此map中包含的值的 Collection 视图。集合由map支持，因此对map的更改会反映在集合中，反之亦然。该集合支持元素删除，即通过 Iterator.remove 、 Collection.remove 、 removeAll 、 retainAll 和 clear 操作从该map中删除相应的映射。它不支持 add 或 addAll 操作。
 视图的迭代器和拆分器是 弱一致 。
 
 视图的 spliterator 报告 Spliterator.CONCURRENT 和 Spliterator.NONNULL 。
 
 指定者：
 
 values 在接口 Map<K,V> 中
 
 重写：
 
 values 在类 AbstractMap<K,V> 中
 
 返回：
 
 集合视图
- entrySet
 
 public Set <Map.Entry <K ,V >> entrySet()
 
 返回此map中包含的映射的 Set 视图。该集合由map支持，因此对map的更改会反映在集合中，反之亦然。该集合支持元素删除，即通过 Iterator.remove 、 Set.remove 、 removeAll 、 retainAll 和 clear 操作从map中删除相应的映射。
 视图的迭代器和拆分器是 弱一致 。
 
 视图的 spliterator 报告 Spliterator.CONCURRENT 、 Spliterator.DISTINCT 和 Spliterator.NONNULL 。
 
 指定者：
 
 entrySet 在接口 Map<K,V> 中
 
 返回：
 
 集合视图
- hashCode
 
 public int hashCode()
 
 返回此 Map 的哈希码值，即map中每个键值对的哈希码值 key.hashCode() ^ value.hashCode() 的总和。
 指定者：
 
 hashCode 在接口 Map<K,V> 中
 
 重写：
 
 hashCode 在类 AbstractMap<K,V> 中
 
 返回：
 
 此map的哈希码值
 
 参见：
 
 Map.Entry.hashCode()
 
 Object.equals(Object)
 
 Set.equals(Object)
- toString
 
 public String toString()
 
 返回此map的字符串表示形式。字符串表示由括在大括号 ("{} ") 中的键值映射列表（无特定顺序）组成。相邻映射由字符 ", "（逗号和空格）分隔。每个键值映射呈现为键后跟等号（“=”）后跟关联值。
 
 重写：
 
 toString 在类 AbstractMap<K,V> 中
 
 返回：
 
 此map的字符串表示形式
- equals
 
 public boolean equals(Object o)
 
 比较指定对象与此map是否相等。如果给定对象是与此map具有相同映射关系的map，则返回 true。如果在执行此方法期间同时修改了任一映射，则此操作可能会返回误导性结果。
 指定者：
 
 equals 在接口 Map<K,V> 中
 
 重写：
 
 equals 在类 AbstractMap<K,V> 中
 
 参数：
 
 o - 要与此map进行相等比较的对象
 
 返回：
 
 true 如果指定的对象等于这个map
 
 参见：
 
 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);
 除了动作是原子执行的。
 指定者：
 
 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 - 如果指定的键为空
- 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 - 如果任何参数为空
- 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)
 
 返回指定键映射到的值，如果此map不包含键的映射，则返回给定的默认值。
 
 指定者：
 
 getOrDefault 在接口 ConcurrentMap<K,V> 中
 
 指定者：
 
 getOrDefault 在接口 Map<K,V> 中
 
 参数：
 
 key - 要返回其关联值的键
 
 defaultValue - 如果此map不包含给定键的映射，则返回值
 
 返回：
 
 密钥的映射（如果存在）；否则默认值
 
 抛出：
 
 NullPointerException - 如果指定的键为空
- computeIfAbsent
 
 public V computeIfAbsent(K key, Function <? super K ,? extends V > mappingFunction)
 
 如果指定的键尚未与值关联，则尝试使用给定的映射函数计算其值并将其输入到此map中，除非 null 。整个方法调用是原子执行的。如果密钥不存在，则每次调用此方法时只调用一次提供的函数，否则根本不调用。当计算正在进行时，其他线程在此map上尝试的一些更新操作可能会被阻塞，因此计算应该简短。
 映射函数在计算期间不得修改此map。
 
 指定者：
 
 computeIfAbsent 在接口 ConcurrentMap<K,V> 中
 
 指定者：
 
 computeIfAbsent 在接口 Map<K,V> 中
 
 参数：
 
 key - 与指定值关联的键
 
 mappingFunction - 计算值的函数
 
 返回：
 
 与指定键关联的当前（现有或计算）值，如果计算值为 null，则为 null
 
 抛出：
 
 NullPointerException - 如果指定的键或 mappingFunction 为 null
 
 IllegalStateException - 如果计算可检测地尝试递归更新此map，否则将永远不会完成
 
 RuntimeException - 如果 mappingFunction 这样做，则为错误，在这种情况下映射未建立
- computeIfPresent
 
 public V computeIfPresent(K key, BiFunction <? super K ,? super V ,? extends V > remappingFunction)
 
 如果存在指定键的值，则尝试在给定键及其当前映射值的情况下计算新映射。整个方法调用是原子执行的。如果密钥存在，则每次调用此方法时仅调用一次提供的函数，否则根本不调用。当计算正在进行时，其他线程在此map上尝试的一些更新操作可能会被阻塞，因此计算应该简短。
 重新映射函数在计算期间不得修改此map。
 
 指定者：
 
 computeIfPresent 在接口 ConcurrentMap<K,V> 中
 
 指定者：
 
 computeIfPresent 在接口 Map<K,V> 中
 
 参数：
 
 key - 值可能关联的键
 
 remappingFunction - 计算值的函数
 
 返回：
 
 与指定键关联的新值，如果没有则为 null
 
 抛出：
 
 NullPointerException - 如果指定的键或 remappingFunction 为 null
 
 IllegalStateException - 如果计算可检测地尝试递归更新此map，否则将永远不会完成
 
 RuntimeException - 如果 remappingFunction 这样做，则为错误，在这种情况下映射未更改
- compute
 
 public V compute(K key, BiFunction <? super K ,? super V ,? extends V > remappingFunction)
 
 尝试计算指定键及其当前映射值的映射（如果没有当前映射，则为 null）。整个方法调用是原子执行的。每次调用此方法时，提供的函数只调用一次。当计算正在进行时，其他线程在此map上尝试的一些更新操作可能会被阻塞，因此计算应该简短。
 重新映射函数在计算期间不得修改此map。
 
 指定者：
 
 compute 在接口 ConcurrentMap<K,V> 中
 
 指定者：
 
 compute 在接口 Map<K,V> 中
 
 参数：
 
 key - 与指定值关联的键
 
 remappingFunction - 计算值的函数
 
 返回：
 
 与指定键关联的新值，如果没有则为 null
 
 抛出：
 
 NullPointerException - 如果指定的键或 remappingFunction 为 null
 
 IllegalStateException - 如果计算可检测地尝试递归更新此map，否则将永远不会完成
 
 RuntimeException - 如果 remappingFunction 这样做，则为错误，在这种情况下映射未更改
- merge
 
 public V merge(K key, V value, BiFunction <? super V ,? super V ,? extends V > remappingFunction)
 
 如果指定键尚未与（非空）值关联，则将其与给定值关联。否则，用给定重映射函数的结果替换该值，或者删除 if null 。整个方法调用是原子执行的。当计算正在进行时，其他线程对此map的一些尝试更新操作可能会被阻塞，因此计算应该简短，并且不得尝试更新此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 - 要搜索的值
 
 返回：
 
 true 当且仅当某些键映射到由 equals 方法确定的此表中的 value 参数时； 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 ，由从给定类型到 Boolean.TRUE 的 ConcurrentHashMap 支持。
 
 类型参数：
 
 K - 返回集合的元素类型
 
 返回：
 
 新系列
 
 自从：
 
 1.8
- newKeySet
 
 public static <K> ConcurrentHashMap.KeySetView <K,Boolean > newKeySet(int initialCapacity)
 
 创建一个新的 Set ，由从给定类型到 Boolean.TRUE 的 ConcurrentHashMap 支持。
 
 类型参数：
 
 K - 返回集合的元素类型
 
 参数：
 
 initialCapacity - 该实现执行内部大小调整以容纳这么多元素。
 
 返回：
 
 新系列
 
 抛出：
 
 IllegalArgumentException - 如果元素的初始容量为负
 
 自从：
 
 1.8
- keySet
 
 public ConcurrentHashMap.KeySetView <K ,V > keySet(V mappedValue)
 
 返回此map中键的 Set 视图，使用给定的公共映射值进行任何添加（即 Collection.add(E) 和 Collection.addAll(Collection) ）。这当然只有在可以接受对该视图的所有添加使用相同的值时才合适。
 
 参数：
 
 mappedValue - 用于任何添加的映射值
 
 返回：
 
 集合视图
 
 抛出：
 
 NullPointerException - 如果 mappedValue 为空
- forEach
 
 public void forEach(long parallelismThreshold, BiConsumer <? super K ,? super V > action)
 
 对每个（键，值）执行给定的操作。
 
 参数：
 
 parallelismThreshold - 并行执行此操作所需的（估计）元素数
 
 action - 动作
 
 自从：
 
 1.8
- forEach
 
 public void forEach(long parallelismThreshold, BiFunction <? super K ,? super V ,? extends U> transformer, Consumer <? super U> action)
 
 对每个（键，值）的每个非空转换执行给定的操作。
 
 类型参数：
 
 U - 转换器的返回类型
 
 参数：
 
 parallelismThreshold - 并行执行此操作所需的（估计）元素数
 
 transformer - 返回元素转换的函数，如果没有转换则为 null（在这种情况下不应用操作）
 
 action - 动作
 
 自从：
 
 1.8
- search
 
 public U search(long parallelismThreshold, BiFunction <? super K ,? super V ,? extends U> searchFunction)
 
 通过对每个 (key, value) 应用给定的搜索函数返回一个非空结果，如果没有则返回 null。成功后，进一步的元素处理将被抑制，搜索功能的任何其他并行调用的结果将被忽略。
 
 类型参数：
 
 U - 搜索函数的返回类型
 
 参数：
 
 parallelismThreshold - 并行执行此操作所需的（估计）元素数
 
 searchFunction - 成功时返回非空结果的函数，否则为空
 
 返回：
 
 对每个（键，值）应用给定搜索函数的非空结果，如果没有则为空
 
 自从：
 
 1.8
- reduce
 
 public 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 void forEachKey(long parallelismThreshold, Function <? super K ,? extends U> transformer, Consumer <? super U> action)
 
 对每个键的每个非空转换执行给定的操作。
 
 类型参数：
 
 U - 转换器的返回类型
 
 参数：
 
 parallelismThreshold - 并行执行此操作所需的（估计）元素数
 
 transformer - 返回元素转换的函数，如果没有转换则为 null（在这种情况下不应用操作）
 
 action - 动作
 
 自从：
 
 1.8
- searchKeys
 
 public U searchKeys(long parallelismThreshold, Function <? super K ,? extends U> searchFunction)
 
 通过在每个键上应用给定的搜索函数返回非空结果，如果没有则返回空。成功后，进一步的元素处理将被抑制，搜索功能的任何其他并行调用的结果将被忽略。
 
 类型参数：
 
 U - 搜索函数的返回类型
 
 参数：
 
 parallelismThreshold - 并行执行此操作所需的（估计）元素数
 
 searchFunction - 成功时返回非空结果的函数，否则为空
 
 返回：
 
 在每个键上应用给定搜索函数的非空结果，如果没有则为空
 
 自从：
 
 1.8
- reduceKeys
 
 public K reduceKeys(long parallelismThreshold, BiFunction <? super K ,? super K ,? extends K > reducer)
 
 返回使用给定的缩减器累积所有键以组合值的结果，如果没有则返回 null。
 
 参数：
 
 parallelismThreshold - 并行执行此操作所需的（估计）元素数
 
 reducer - 可交换关联组合函数
 
 返回：
 
 使用给定的缩减器累积所有键以组合值的结果，如果没有则为 null
 
 自从：
 
 1.8
- reduceKeys
 
 public 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 void forEachValue(long parallelismThreshold, Function <? super V ,? extends U> transformer, Consumer <? super U> action)
 
 对每个值的每个非空转换执行给定的操作。
 
 类型参数：
 
 U - 转换器的返回类型
 
 参数：
 
 parallelismThreshold - 并行执行此操作所需的（估计）元素数
 
 transformer - 返回元素转换的函数，如果没有转换则为 null（在这种情况下不应用操作）
 
 action - 动作
 
 自从：
 
 1.8
- searchValues
 
 public U searchValues(long parallelismThreshold, Function <? super V ,? extends U> searchFunction)
 
 通过对每个值应用给定的搜索函数返回非空结果，如果没有则返回空。成功后，进一步的元素处理将被抑制，搜索功能的任何其他并行调用的结果将被忽略。
 
 类型参数：
 
 U - 搜索函数的返回类型
 
 参数：
 
 parallelismThreshold - 并行执行此操作所需的（估计）元素数
 
 searchFunction - 成功时返回非空结果的函数，否则为空
 
 返回：
 
 对每个值应用给定搜索函数的非空结果，如果没有则为空
 
 自从：
 
 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 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 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 searchEntries(long parallelismThreshold, Function <Map.Entry <K ,V >,? extends U> searchFunction)
 
 通过在每个条目上应用给定的搜索函数返回非空结果，如果没有则返回空。成功后，进一步的元素处理将被抑制，搜索功能的任何其他并行调用的结果将被忽略。
 
 类型参数：
 
 U - 搜索函数的返回类型
 
 参数：
 
 parallelismThreshold - 并行执行此操作所需的（估计）元素数
 
 searchFunction - 成功时返回非空结果的函数，否则为空
 
 返回：
 
 对每个条目应用给定搜索函数的非空结果，如果没有则为空
 
 自从：
 
 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 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

类 ConcurrentHashMap<K,V>

内部类总结

在类 java.util.AbstractMap 中声明的嵌套类/接口

在接口 java.util.Map 中声明的嵌套类/接口

构造方法总结

方法总结

在类 java.util.AbstractMap 中声明的方法

在类 java.lang.Object 中声明的方法

在接口 java.util.concurrent.ConcurrentMap 中声明的方法

构造方法详细信息

ConcurrentHashMap

ConcurrentHashMap

ConcurrentHashMap

ConcurrentHashMap

ConcurrentHashMap

方法详情

size

isEmpty

get

containsKey

containsValue

put

putAll

remove

clear

keySet

values

entrySet

hashCode

toString

equals

putIfAbsent

remove

replace

replace

getOrDefault

computeIfAbsent

computeIfPresent

compute

merge

contains

keys

elements

mappingCount

newKeySet

newKeySet

keySet

forEach

forEach

search

reduce

reduceToDouble

reduceToLong

reduceToInt

forEachKey

forEachKey

searchKeys

reduceKeys

reduceKeys

reduceKeysToDouble

reduceKeysToLong

reduceKeysToInt

forEachValue

forEachValue

searchValues

reduceValues

reduceValues

reduceValuesToDouble

reduceValuesToLong

reduceValuesToInt

forEachEntry

forEachEntry

searchEntries

reduceEntries

reduceEntries

reduceEntriesToDouble

reduceEntriesToLong

reduceEntriesToInt