ConcurrentHashMap (Java Platform SE 8 )

java.lang.Object
- java.util.AbstractMap<K,V>
- - java.util.concurrent.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()是降低任何哈希表的hashCode()的一种可靠的方法。为了改善影响，当按键为Comparable时，该类可以使用键之间的比较顺序来帮助打破关系。

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

ConcurrentHashMap可以通过使用LongAdder值并通过computeIfAbsent进行初始化，将其用作可缩放的频率映射（直方图或多集的形式）。例如，要向ConcurrentHashMap<String,LongAdder> freqs添加计数，可以使用freqs.computeIfAbsent(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的值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 new AbstractMap.SimpleEntry(k,v) 。

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

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

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

这个班是Java Collections Framework的会员。
从以下版本开始：

1.5

另请参见：

Serialized Form

Nested Class Summary

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

Nested classes/interfaces inherited from class java.util.AbstractMap
AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>

Nested classes/interfaces inherited from interface java.util.Map
Map.Entry<K,V>

构造方法摘要

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

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`void`	`clear()` 从这张地图中删除所有的映射。
`V`	`compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)` 尝试计算用于指定键和其当前映射的值的映射（或 `null`如果没有当前映射）。
`V`	`computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)` 如果指定的键尚未与值相关联，则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 `null` 。
`V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)` 如果存在指定键的值，则尝试计算给出键的新映射及其当前映射值。
`boolean`	`contains(Object value)` 传统方法测试如果一些键映射到此表中的指定值。
`boolean`	`containsKey(Object key)` 测试此表中的指定对象是否为键。
`boolean`	`containsValue(Object value)` 如果此映射将一个或多个键映射到指定的值，则返回 `true` 。
`Enumeration<V>`	`elements()` 返回此表中值的枚举。
`Set<Map.Entry<K,V>>`	`entrySet()` 返回此地图中包含的映射的`Set`视图。
`boolean`	`equals(Object o)` 将指定的对象与此映射进行比较以获得相等性。
`void`	`forEach(BiConsumer<? super K,? super V> action)` 对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
`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`	`forEachEntry(long parallelismThreshold, Consumer<? super Map.Entry<K,V>> action)` 对每个条目执行给定的操作。
`<U> void`	`forEachEntry(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> transformer, Consumer<? super U> action)` 对每个条目的每个非空变换执行给定的操作。
`void`	`forEachKey(long parallelismThreshold, Consumer<? super K> action)` 对每个键执行给定的动作。
`<U> void`	`forEachKey(long parallelismThreshold, Function<? super K,? extends U> transformer, Consumer<? super U> action)` 对每个键的每个非空变换执行给定的动作。
`void`	`forEachValue(long parallelismThreshold, Consumer<? super V> action)` 对每个值执行给定的操作。
`<U> void`	`forEachValue(long parallelismThreshold, Function<? super V,? extends U> transformer, Consumer<? super U> action)` 对每个值的每个非空转换执行给定的动作。
`V`	`get(Object key)` 返回到指定键所映射的值，或 `null`如果此映射包含该键的映射。
`V`	`getOrDefault(Object key, V defaultValue)` 返回指定键映射到的值，如果此映射不包含该键的映射，则返回给定的默认值。
`int`	`hashCode()` 返回此`Map`的哈希代码值，即映射中每个键值对的总和，即`key.hashCode() ^ value.hashCode()` 。
`boolean`	`isEmpty()` 如果此地图不包含键值映射，则返回 `true` 。
`Enumeration<K>`	`keys()` 返回此表中键的枚举。
`ConcurrentHashMap.KeySetView<K,V>`	`keySet()` 返回此地图中包含的键的`Set`视图。
`ConcurrentHashMap.KeySetView<K,V>`	`keySet(V mappedValue)` 返回此地图中键的`Set`视图，使用给定的公用映射值进行任何添加（即`Collection.add(E)`和`Collection.addAll(Collection)` ）。
`long`	`mappingCount()` 返回映射数。
`V`	`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)` 如果指定的键尚未与（非空）值相关联，则将其与给定值相关联。
`static <K> ConcurrentHashMap.KeySetView<K,Boolean>`	`newKeySet()` 创建一个新的`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`视图。

Methods inherited from class java.util.AbstractMap
clone

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- 构造方法详细信息
 - 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 - 如果初始容量为负值或负载因子或并发级别为非正性
- 方法详细信息
 - 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>
 - keySet
```
public ConcurrentHashMap.KeySetView<K,V> keySet()
```
 返回此地图中包含的键的Set视图。该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。该组支持元件移除，即从该映射中相应的映射，经由Iterator.remove ， Set.remove ， removeAll ， retainAll和clear操作。它不支持add或addAll操作。
 视图的迭代器和拼接器是weakly consistent 。
 
 视图的spliterator报告Spliterator.CONCURRENT ， Spliterator.DISTINCT和Spliterator.NONNULL 。
 
 Specified by:
 
 keySet在接口 Map<K,V>
 
 重写：
 
 keySet在类别 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>
 
 Specified by:
 
 entrySet在类别 AbstractMap<K,V>
 
 结果
 
 设置视图
 - hashCode
```
public int hashCode()
```
 返回这个Map的哈希码值，即地图中每个键值对的总和，即key.hashCode() ^ value.hashCode() 。
 
 Specified by:
 
 hashCode在界面 Map<K,V>
 
 重写：
 
 hashCode在类别 AbstractMap<K,V>
 
 结果
 
 该地图的哈希码值
 
 另请参见：
 
 Map.Entry.hashCode() ， Object.equals(Object) ， Set.equals(Object)
 - 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)
```
 如果指定的键尚未与值相关联，请将其与给定值相关联。这相当于
```
 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)
```
 仅当当前映射到给定值时才删除密钥的条目。这相当于
```
 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)
```
 仅当当前映射到给定值时才替换密钥的条目。这相当于
```
 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)
```
 仅当当前映射到某个值时才替换该项的条目。这相当于
```
 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 - 如果指定的键或remappingFunction为空
 
 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 - 如果指定的键或remappingFunction为空
 
 IllegalStateException - 如果计算可检测地尝试递归更新该映射，否则将永远不会完成
 
 RuntimeException - 或者如果remappingFunction这样做，则出错，在这种情况下映射不变
 - 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 - 如果指定的键或remappingFunction为空
 
 RuntimeException - 或者如果重映射功能如此，则出错，在这种情况下映射不变
 - contains
```
public boolean contains(Object value)
```
 传统方法测试如果一些键映射到此表中的指定值。该方法在功能上与containsValue(Object)相同，仅存在于确保与引入 Java Collections框架之前支持此方法的Hashtable类的完全兼容性。
 
 参数
 
 value - 要搜索的值
 
 结果
 
 true当且仅当某些键映射到本表中的value参数，由equals方法确定; false否则
 
 异常
 
 NullPointerException - 如果指定的值为null
 - 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
 - keySet
```
public ConcurrentHashMap.KeySetView<K,V> keySet(V mappedValue)
```
 返回此地图中键的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)
```
 对每个（key，value）的每个非空变换执行给定的动作。
 
 参数类型
 
 U - U的返回类型
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
 
 transformer - 返回元素的变换的函数，如果没有变换，则返回null（在这种情况下，不应用动作）
 
 action - 行动
 
 从以下版本开始：
 
 1.8
 - search
```
public  U search(long parallelismThreshold,
 BiFunction<? super K,? super V,? extends U> searchFunction)
```
 通过在每个（键，值）上应用给定的搜索函数返回非空结果，如果没有则返回null。成功后，进一步的元素处理被抑制，并且搜索功能的任何其他并行调用的结果被忽略。
 
 参数类型
 
 U - 搜索功能的返回类型
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素数量（估计）
 
 searchFunction - 成功返回非空结果的函数，否则为null
 
 结果
 
 在每个（键值）上应用给定搜索函数的非空结果，如果没有，则返回null
 
 从以下版本开始：
 
 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 - 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 - 返回元素 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 - U的返回类型
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
 
 transformer - 返回元素的变换的函数，如果没有变换则为null（在这种情况下，不应用动作）
 
 action - 行动
 
 从以下版本开始：
 
 1.8
 - searchKeys
```
public  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 reduceKeys(long parallelismThreshold,
 Function<? super K,? extends U> transformer,
 BiFunction<? super U,? super U,? extends U> reducer)
```
 返回使用给定的reducer累加所有键的给定变换以组合值的结果，如果没有则返回null。
 
 参数类型
 
 U - 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 - 返回元素 transformer的函数
 
 basis - 减少的身份（初始默认值）
 
 reducer - 交换联想组合功能
 
 结果
 
 积累所有键的给定变换的结果
 
 从以下版本开始：
 
 1.8
 - reduceKeysToInt
```
public int reduceKeysToInt(long parallelismThreshold,
 ToIntFunction<? super K> transformer,
 int basis,
 IntBinaryOperator reducer)
```
 返回使用给定的reducer累加所有键的给定变换的结果，以组合值，给定基础作为标识值。
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
 
 transformer - 返回元素 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 - U的返回类型
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
 
 transformer - 返回元素的变换的函数，如果没有变换则为null（在这种情况下，不应用动作）
 
 action - 行动
 
 从以下版本开始：
 
 1.8
 - searchValues
```
public  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 reduceValues(long parallelismThreshold,
 Function<? super V,? extends U> transformer,
 BiFunction<? super U,? super U,? extends U> reducer)
```
 返回使用给定的reducer累加所有值的给定变换以组合值的结果，否则返回null。
 
 参数类型
 
 U - U的返回类型
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
 
 transformer - 一个返回元素变换的函数，如果没有变换，则返回null（在这种情况下不组合）
 
 reducer - 一种交换联想组合函数
 
 结果
 
 积累所有值的给定变换的结果
 
 从以下版本开始：
 
 1.8
 - reduceValuesToDouble
```
public double reduceValuesToDouble(long parallelismThreshold,
 ToDoubleFunction<? super V> transformer,
 double basis,
 DoubleBinaryOperator reducer)
```
 返回使用给定的reducer累加所有值的给定变换的结果，以组合值，给定基础作为标识值。
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
 
 transformer - 返回元素 transformer的函数
 
 basis - 减少的身份（初始默认值）
 
 reducer - 交换联想组合函数
 
 结果
 
 积累所有值的给定变换的结果
 
 从以下版本开始：
 
 1.8
 - reduceValuesToLong
```
public long reduceValuesToLong(long parallelismThreshold,
 ToLongFunction<? super V> transformer,
 long basis,
 LongBinaryOperator reducer)
```
 返回使用给定的reducer累加所有值的给定变换的结果，以组合值，给定基础作为标识值。
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
 
 transformer - 返回元素 transformer的函数
 
 basis - 减少的身份（初始默认值）
 
 reducer - 交换联想组合功能
 
 结果
 
 积累所有值的给定变换的结果
 
 从以下版本开始：
 
 1.8
 - reduceValuesToInt
```
public int reduceValuesToInt(long parallelismThreshold,
 ToIntFunction<? super V> transformer,
 int basis,
 IntBinaryOperator reducer)
```
 返回使用给定的reducer累加所有值的给定变换的结果，以组合值，给定基础作为标识值。
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
 
 transformer - 返回元素 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 - U的返回类型
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素数量（估计）
 
 transformer - 返回元素的变换的函数，如果没有变换则为null（在这种情况下，不应用动作）
 
 action - 行动
 
 从以下版本开始：
 
 1.8
 - searchEntries
```
public  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 reduceEntries(long parallelismThreshold,
 Function<Map.Entry<K,V>,? extends U> transformer,
 BiFunction<? super U,? super U,? extends U> reducer)
```
 返回使用给定的reducer将所有条目的给定变换累加到组合值的结果，否则返回null。
 
 参数类型
 
 U - 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 - 返回元素 transformer的函数
 
 basis - 减少的身份（初始默认值）
 
 reducer - 一种交换联想组合函数
 
 结果
 
 累积所有条目的给定转换的结果
 
 从以下版本开始：
 
 1.8
 - reduceEntriesToLong
```
public long reduceEntriesToLong(long parallelismThreshold,
 ToLongFunction<Map.Entry<K,V>> transformer,
 long basis,
 LongBinaryOperator reducer)
```
 返回使用给定的reducer累加给定变换的结果，以组合值，给定基础作为一个标识值。
 
 参数
 
 parallelismThreshold - 并行执行此操作所需的元素的（估计）数量
 
 transformer - 返回元素 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

Class ConcurrentHashMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap

Nested classes/interfaces inherited from interface java.util.Map

构造方法摘要

方法摘要

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

构造方法详细信息

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

forEach

replaceAll

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