java.lang.Object
- org.eclipse.collections.impl.AbstractRichIterable<V>
- - org.eclipse.collections.impl.map.AbstractMapIterable<K,V>
  - - org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable<K,V>
    - - org.eclipse.collections.impl.map.mutable.AbstractMutableMap<K,V>
      - org.eclipse.collections.impl.map.mutable.ConcurrentHashMap<K,V>

All Implemented Interfaces:

Externalizable, Serializable, Cloneable, Iterable<V>, ConcurrentMap<K,V>, Map<K,V>, InternalIterable<V>, ConcurrentMutableMap<K,V>, MapIterable<K,V>, MutableMap<K,V>, MutableMapIterable<K,V>, UnsortedMapIterable<K,V>, RichIterable<V>
```
public final class ConcurrentHashMap<K,V>
extends AbstractMutableMap<K,V>
implements ConcurrentMutableMap<K,V>, Externalizable
```
See Also:

Serialized Form

Constructor Summary

Constructors
Constructor Description

ConcurrentHashMap()

ConcurrentHashMap(int initialCapacity)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`clear()`
`MutableMap<K,V>`	`clone()`
`<E> MutableMap<K,V>`	`collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Set<Map.Entry<K,V>>`	`entrySet()`
`boolean`	`equals(Object o)`
`void`	`forEachKey(Procedure<? super K> procedure)`
`void`	`forEachKeyValue(Procedure2<? super K,? super V> procedure)`
`void`	`forEachValue(Procedure<? super V> procedure)`
`<P> void`	`forEachWith(Procedure2<? super V,? super P> procedure, P parameter)`
`void`	`forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure)`
`V`	`get(Object key)`
`V`	`getIfAbsent(K key, Function0<? extends V> function)`
`V`	`getIfAbsentPut(K key, Function<? super K,? extends V> factory)`
`V`	`getIfAbsentPut(K key, Function0<? extends V> factory)`
`V`	`getIfAbsentPut(K key, V value)`
`<P> V`	`getIfAbsentPutWith(K key, Function<? super P,? extends V> function, P parameter)`
`<P> V`	`getIfAbsentWith(K key, Function<? super P,? extends V> function, P parameter)`
`int`	`hashCode()`
`<A> A`	`ifPresentApply(K key, Function<? super V,? extends A> function)`
`boolean`	`isEmpty()`
`Iterator<V>`	`iterator()`
`Set<K>`	`keySet()`
`MutableMap<K,V>`	`newEmpty()`
`<K,V> MutableMap<K,V>`	`newEmpty(int capacity)`	Creates a new instance of the same type, using the given capacity and the default growth parameters.
`static <K,V> ConcurrentHashMap<K,V>`	`newMap()`
`static <K,V> ConcurrentHashMap<K,V>`	`newMap(int newSize)`
`static <NK,NV> ConcurrentHashMap<NK,NV>`	`newMap(Map<NK,NV> map)`
`boolean`	`notEmpty()`
`void`	`parallelForEachKeyValue(List<Procedure2<K,V>> blocks, Executor executor)`
`void`	`parallelForEachValue(List<Procedure<V>> blocks, Executor executor)`
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> map)`
`void`	`putAllInParallel(Map<? extends K,? extends V> map, int chunks, Executor executor)`
`V`	`putIfAbsent(K key, V value)`
`<P1,P2> V`	`putIfAbsentGetIfPresent(K key, Function2<? super K,? super V,? extends K> keyTransformer, Function3<P1,P2,? super K,? extends V> factory, P1 param1, P2 param2)`	It puts an object into the map based on the key.
`void`	`readExternal(ObjectInput in)`
`V`	`remove(Object key)`
`boolean`	`remove(Object key, Object value)`
`V`	`removeKey(K key)`
`V`	`replace(K key, V value)`
`boolean`	`replace(K key, V oldValue, V newValue)`
`int`	`size()`
`ConcurrentMutableMap<K,V>`	`tap(Procedure<? super V> procedure)`
`ImmutableMap<K,V>`	`toImmutable()`
`String`	`toString()`	Returns a string with the elements of the iterable separated by commas with spaces and enclosed in square brackets.
`V`	`updateValue(K key, Function0<? extends V> factory, Function<? super V,? extends V> function)`
`<P> V`	`updateValueWith(K key, Function0<? extends V> factory, Function2<? super V,? super P,? extends V> function, P parameter)`
`Collection<V>`	`values()`
`ConcurrentHashMap<K,V>`	`withAllKeyValueArguments(Pair<? extends K,? extends V>... keyValues)`
`ConcurrentHashMap<K,V>`	`withAllKeyValues(Iterable<? extends Pair<? extends K,? extends V>> keyValues)`
`ConcurrentHashMap<K,V>`	`withKeyValue(K key, V value)`
`ConcurrentHashMap<K,V>`	`withMap(Map<? extends K,? extends V> map)`
`ConcurrentHashMap<K,V>`	`withMapIterable(MapIterable<? extends K,? extends V> mapIterable)`
`ConcurrentHashMap<K,V>`	`withoutAllKeys(Iterable<? extends K> keys)`
`ConcurrentHashMap<K,V>`	`withoutKey(K key)`
`void`	`writeExternal(ObjectOutput out)`

Methods inherited from class org.eclipse.collections.impl.map.mutable.AbstractMutableMap
asSynchronized, asUnmodifiable, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectValues, collectWith, flatCollect, flip, groupBy, groupByEach, groupByUniqueKey, partition, partitionWith, reject, reject, rejectWith, select, select, selectInstancesOf, selectWith, zip, zipWithIndex

Methods inherited from class org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable
aggregateBy, collect, countBy, countByEach, countByWith, detect, detectOptional, flipUniqueValues, getIfAbsentPutWithKey, keysView, keyValuesView, sumByDouble, sumByFloat, sumByInt, sumByLong, valuesView

Methods inherited from class org.eclipse.collections.impl.map.AbstractMapIterable
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, asLazy, chunk, contains, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, getFirst, getIfAbsentValue, getLast, getOnly, getOrDefault, noneSatisfy, noneSatisfyWith, toArray, toArray

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable
appendString, appendString, collect, collectIf, collectWith, containsAll, containsAllArguments, containsAllIterable, count, countWith, flatCollect, forEach, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, into, max, max, maxBy, min, min, minBy, reject, rejectWith, select, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBag, toBiMap, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndex

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

Methods inherited from interface java.util.concurrent.ConcurrentMap
compute, computeIfAbsent, computeIfPresent, merge, replaceAll

Methods inherited from interface org.eclipse.collections.api.map.ConcurrentMutableMap
forEach, getOrDefault

Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach

Methods inherited from interface org.eclipse.collections.api.map.MapIterable
detect, detectOptional, getIfAbsentValue, injectIntoKeyValue, keysView, keyValuesView, parallelStream, spliterator, stream, valuesView

Methods inherited from interface org.eclipse.collections.api.map.MutableMap
aggregateBy, aggregateBy, aggregateInPlaceBy, asSynchronized, asUnmodifiable, collect, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectValues, collectWith, flatCollect, flatCollectWith, flip, flipUniqueValues, groupBy, groupByEach, groupByUniqueKey, partition, partitionWith, reject, reject, rejectWith, select, select, selectInstancesOf, selectWith, zip, zipWithIndex

Methods inherited from interface org.eclipse.collections.api.map.MutableMapIterable
add, countBy, countByEach, countByWith, getIfAbsentPutWithKey, putAllMapIterable, putPair, removeAllKeys, removeIf, sumByDouble, sumByFloat, sumByInt, sumByLong

Methods inherited from interface org.eclipse.collections.api.RichIterable
aggregateBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, containsAny, containsAnyIterable, containsBy, containsNone, containsNoneIterable, count, countBy, countByEach, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, flatCollectWith, forEach, getAny, getFirst, getLast, getOnly, groupBy, groupByAndCollect, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, into, makeString, makeString, makeString, makeString, max, max, maxBy, maxByOptional, maxOptional, maxOptional, min, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, reduce, reduceInPlace, reduceInPlace, reject, rejectWith, select, selectWith, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toImmutableBag, toImmutableBiMap, toImmutableList, toImmutableMap, toImmutableSet, toImmutableSortedBag, toImmutableSortedBag, toImmutableSortedBagBy, toImmutableSortedList, toImmutableSortedList, toImmutableSortedListBy, toImmutableSortedSet, toImmutableSortedSet, toImmutableSortedSetBy, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndex

- Constructor Detail
  - ConcurrentHashMap
```
public ConcurrentHashMap()
```
  - ConcurrentHashMap
```
public ConcurrentHashMap(int initialCapacity)
```
- Method Detail
  - newMap
```
public static <K,V> ConcurrentHashMap<K,V> newMap()
```
  - newMap
```
public static <K,V> ConcurrentHashMap<K,V> newMap(int newSize)
```
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface Map<K,V>
  - getIfAbsentPut
```
public V getIfAbsentPut(K key,
                        Function<? super K,? extends V> factory)
```
  - getIfAbsentPut
```
public V getIfAbsentPut(K key,
                        Function0<? extends V> factory)
```
    Specified by:
    
    getIfAbsentPut in interface MutableMapIterable<K,V>
    
    Overrides:
    
    getIfAbsentPut in class AbstractMutableMapIterable<K,V>
  - getIfAbsentPut
```
public V getIfAbsentPut(K key,
                        V value)
```
    Specified by:
    
    getIfAbsentPut in interface MutableMapIterable<K,V>
    
    Overrides:
    
    getIfAbsentPut in class AbstractMutableMapIterable<K,V>
  - putIfAbsentGetIfPresent
```
public <P1,P2> V putIfAbsentGetIfPresent(K key,
                                               Function2<? super K,? super V,? extends K> keyTransformer,
                                               Function3<P1,P2,? super K,? extends V> factory,
                                               P1 param1,
                                               P2 param2)
```
    It puts an object into the map based on the key. It uses a copy of the key converted by transformer.
    
    Parameters:
    
    key - The "mutable" key, which has the same identity/hashcode as the inserted key, only during this call
    
    keyTransformer - If the record is absent, the transformer will transform the "mutable" key into an immutable copy of the key. Note that the transformed key must have the same identity/hashcode as the original "mutable" key.
    
    factory - It creates an object, if it is not present in the map already.
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Specified by:
    
    remove in interface ConcurrentMap<K,V>
    
    Specified by:
    
    remove in interface Map<K,V>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<K,V>
    
    Specified by:
    
    size in interface RichIterable<K>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,V>
    
    Specified by:
    
    isEmpty in interface RichIterable<K>
    
    Overrides:
    
    isEmpty in class AbstractRichIterable<V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
    
    Specified by:
    
    containsKey in interface MapIterable<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<K,V>
    
    Specified by:
    
    containsValue in interface MapIterable<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
    
    Specified by:
    
    get in interface MapIterable<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
  - putAllInParallel
```
public void putAllInParallel(Map<? extends K,? extends V> map,
                             int chunks,
                             Executor executor)
```
  - putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - keySet
```
public Set<K> keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - replace
```
public V replace(K key,
                 V value)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
  - parallelForEachKeyValue
```
public void parallelForEachKeyValue(List<Procedure2<K,V>> blocks,
                                    Executor executor)
```
  - parallelForEachValue
```
public void parallelForEachValue(List<Procedure<V>> blocks,
                                 Executor executor)
```
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<K,V>
    
    Specified by:
    
    hashCode in interface MapIterable<K,V>
    
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Map<K,V>
    
    Specified by:
    
    equals in interface MapIterable<K,V>
    
    Overrides:
    
    equals in class Object
  - toString
```
public String toString()
```
    Description copied from class: AbstractRichIterable
    Returns a string with the elements of the iterable separated by commas with spaces and enclosed in square brackets.
    Assert.assertEquals("[]", Lists.mutable.empty().toString()); Assert.assertEquals("[1]", Lists.mutable.with(1).toString()); Assert.assertEquals("[1, 2, 3]", Lists.mutable.with(1, 2, 3).toString());
    Specified by:
    
    toString in interface MapIterable<K,V>
    
    Specified by:
    
    toString in interface RichIterable<K>
    
    Overrides:
    
    toString in class AbstractRichIterable<V>
    
    Returns:
    
    a string representation of this collection.
    
    See Also:
    
    AbstractCollection.toString()
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - newMap
```
public static <NK,NV> ConcurrentHashMap<NK,NV> newMap(Map<NK,NV> map)
```
  - withKeyValue
```
public ConcurrentHashMap<K,V> withKeyValue(K key,
                                                 V value)
```
    Specified by:
    
    withKeyValue in interface MutableMap<K,V>
    
    Specified by:
    
    withKeyValue in interface MutableMapIterable<K,V>
    
    Overrides:
    
    withKeyValue in class AbstractMutableMap<K,V>
  - withMap
```
public ConcurrentHashMap<K,V> withMap(Map<? extends K,? extends V> map)
```
    Specified by:
    
    withMap in interface ConcurrentMutableMap<K,V>
    
    Specified by:
    
    withMap in interface MutableMap<K,V>
    
    Specified by:
    
    withMap in interface MutableMapIterable<K,V>
  - withMapIterable
```
public ConcurrentHashMap<K,V> withMapIterable(MapIterable<? extends K,? extends V> mapIterable)
```
    Specified by:
    
    withMapIterable in interface ConcurrentMutableMap<K,V>
    
    Specified by:
    
    withMapIterable in interface MutableMap<K,V>
    
    Specified by:
    
    withMapIterable in interface MutableMapIterable<K,V>
  - withAllKeyValues
```
public ConcurrentHashMap<K,V> withAllKeyValues(Iterable<? extends Pair<? extends K,? extends V>> keyValues)
```
    Specified by:
    
    withAllKeyValues in interface MutableMap<K,V>
    
    Specified by:
    
    withAllKeyValues in interface MutableMapIterable<K,V>
    
    Overrides:
    
    withAllKeyValues in class AbstractMutableMap<K,V>
  - withAllKeyValueArguments
```
public ConcurrentHashMap<K,V> withAllKeyValueArguments(Pair<? extends K,? extends V>... keyValues)
```
    Specified by:
    
    withAllKeyValueArguments in interface MutableMap<K,V>
    
    Specified by:
    
    withAllKeyValueArguments in interface MutableMapIterable<K,V>
    
    Overrides:
    
    withAllKeyValueArguments in class AbstractMutableMap<K,V>
  - withoutKey
```
public ConcurrentHashMap<K,V> withoutKey(K key)
```
    Specified by:
    
    withoutKey in interface MutableMap<K,V>
    
    Specified by:
    
    withoutKey in interface MutableMapIterable<K,V>
    
    Overrides:
    
    withoutKey in class AbstractMutableMap<K,V>
  - withoutAllKeys
```
public ConcurrentHashMap<K,V> withoutAllKeys(Iterable<? extends K> keys)
```
    Specified by:
    
    withoutAllKeys in interface MutableMap<K,V>
    
    Specified by:
    
    withoutAllKeys in interface MutableMapIterable<K,V>
    
    Overrides:
    
    withoutAllKeys in class AbstractMutableMap<K,V>
  - clone
```
public MutableMap<K,V> clone()
```
    Specified by:
    
    clone in interface MutableMap<K,V>
    
    Specified by:
    
    clone in class AbstractMutableMap<K,V>
  - newEmpty
```
public <K,V> MutableMap<K,V> newEmpty(int capacity)
```
    Description copied from class: AbstractMutableMap
    
    Creates a new instance of the same type, using the given capacity and the default growth parameters.
    
    Specified by:
    
    newEmpty in class AbstractMutableMap<K,V>
  - notEmpty
```
public boolean notEmpty()
```
    Specified by:
    
    notEmpty in interface RichIterable<K>
  - forEachWithIndex
```
public void forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure)
```
    Specified by:
    
    forEachWithIndex in interface InternalIterable<K>
    
    Overrides:
    
    forEachWithIndex in class AbstractMapIterable<K,V>
  - iterator
```
public Iterator<V> iterator()
```
    Specified by:
    
    iterator in interface Iterable<K>
    
    Overrides:
    
    iterator in class AbstractMutableMapIterable<K,V>
  - newEmpty
```
public MutableMap<K,V> newEmpty()
```
    Specified by:
    
    newEmpty in interface MutableMap<K,V>
    
    Specified by:
    
    newEmpty in interface MutableMapIterable<K,V>
  - tap
```
public ConcurrentMutableMap<K,V> tap(Procedure<? super V> procedure)
```
    Specified by:
    
    tap in interface ConcurrentMutableMap<K,V>
    
    Specified by:
    
    tap in interface MapIterable<K,V>
    
    Specified by:
    
    tap in interface MutableMap<K,V>
    
    Specified by:
    
    tap in interface MutableMapIterable<K,V>
    
    Specified by:
    
    tap in interface RichIterable<K>
    
    Specified by:
    
    tap in interface UnsortedMapIterable<K,V>
    
    Overrides:
    
    tap in class AbstractMutableMap<K,V>
  - forEachValue
```
public void forEachValue(Procedure<? super V> procedure)
```
    Specified by:
    
    forEachValue in interface MapIterable<K,V>
    
    Overrides:
    
    forEachValue in class AbstractMapIterable<K,V>
  - forEachKey
```
public void forEachKey(Procedure<? super K> procedure)
```
    Specified by:
    
    forEachKey in interface MapIterable<K,V>
    
    Overrides:
    
    forEachKey in class AbstractMapIterable<K,V>
  - forEachKeyValue
```
public void forEachKeyValue(Procedure2<? super K,? super V> procedure)
```
    Specified by:
    
    forEachKeyValue in interface MapIterable<K,V>
  - collectKeysAndValues
```
public <E> MutableMap<K,V> collectKeysAndValues(Iterable<E> iterable,
                                                      Function<? super E,? extends K> keyFunction,
                                                      Function<? super E,? extends V> valueFunction)
```
    Specified by:
    
    collectKeysAndValues in interface MutableMap<K,V>
  - removeKey
```
public V removeKey(K key)
```
    Specified by:
    
    removeKey in interface MutableMapIterable<K,V>
  - getIfAbsentPutWith
```
public <P> V getIfAbsentPutWith(K key,
                                Function<? super P,? extends V> function,
                                P parameter)
```
    Specified by:
    
    getIfAbsentPutWith in interface MutableMapIterable<K,V>
    
    Overrides:
    
    getIfAbsentPutWith in class AbstractMutableMapIterable<K,V>
  - getIfAbsent
```
public V getIfAbsent(K key,
                     Function0<? extends V> function)
```
    Specified by:
    
    getIfAbsent in interface MapIterable<K,V>
    
    Overrides:
    
    getIfAbsent in class AbstractMapIterable<K,V>
  - getIfAbsentWith
```
public <P> V getIfAbsentWith(K key,
                             Function<? super P,? extends V> function,
                             P parameter)
```
    Specified by:
    
    getIfAbsentWith in interface MapIterable<K,V>
    
    Overrides:
    
    getIfAbsentWith in class AbstractMapIterable<K,V>
  - ifPresentApply
```
public <A> A ifPresentApply(K key,
                            Function<? super V,? extends A> function)
```
    Specified by:
    
    ifPresentApply in interface MapIterable<K,V>
    
    Overrides:
    
    ifPresentApply in class AbstractMapIterable<K,V>
  - forEachWith
```
public <P> void forEachWith(Procedure2<? super V,? super P> procedure,
                            P parameter)
```
    Specified by:
    
    forEachWith in interface InternalIterable<K>
    
    Overrides:
    
    forEachWith in class AbstractMapIterable<K,V>
  - updateValue
```
public V updateValue(K key,
                     Function0<? extends V> factory,
                     Function<? super V,? extends V> function)
```
    Specified by:
    
    updateValue in interface MutableMapIterable<K,V>
    
    Overrides:
    
    updateValue in class AbstractMutableMapIterable<K,V>
  - updateValueWith
```
public <P> V updateValueWith(K key,
                             Function0<? extends V> factory,
                             Function2<? super V,? super P,? extends V> function,
                             P parameter)
```
    Specified by:
    
    updateValueWith in interface MutableMapIterable<K,V>
    
    Overrides:
    
    updateValueWith in class AbstractMutableMapIterable<K,V>
  - toImmutable
```
public ImmutableMap<K,V> toImmutable()
```
    Specified by:
    
    toImmutable in interface MapIterable<K,V>
    
    Specified by:
    
    toImmutable in interface MutableMapIterable<K,V>
    
    Specified by:
    
    toImmutable in interface UnsortedMapIterable<K,V>
    
    Overrides:
    
    toImmutable in class AbstractMutableMap<K,V>

Constructor	Description
`ConcurrentHashMap()`
`ConcurrentHashMap(int initialCapacity)`

Class ConcurrentHashMap<K,​V>

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.collections.impl.map.mutable.AbstractMutableMap

Methods inherited from class org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable

Methods inherited from class org.eclipse.collections.impl.map.AbstractMapIterable

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.ConcurrentMap

Methods inherited from interface org.eclipse.collections.api.map.ConcurrentMutableMap

Methods inherited from interface org.eclipse.collections.api.InternalIterable

Methods inherited from interface org.eclipse.collections.api.map.MapIterable

Methods inherited from interface org.eclipse.collections.api.map.MutableMap

Methods inherited from interface org.eclipse.collections.api.map.MutableMapIterable

Methods inherited from interface org.eclipse.collections.api.RichIterable

Constructor Detail

ConcurrentHashMap

ConcurrentHashMap

Method Detail

newMap

newMap

putIfAbsent

getIfAbsentPut

getIfAbsentPut

getIfAbsentPut

putIfAbsentGetIfPresent

remove

size

isEmpty

containsKey

containsValue

get

put

putAllInParallel

putAll

clear

keySet

values

entrySet

replace

replace

remove

parallelForEachKeyValue

parallelForEachValue

hashCode

equals

toString

readExternal

writeExternal

newMap

withKeyValue

withMap

withMapIterable

withAllKeyValues

withAllKeyValueArguments

withoutKey

withoutAllKeys

clone

newEmpty

notEmpty

forEachWithIndex

iterator

newEmpty

tap

forEachValue

forEachKey

forEachKeyValue

collectKeysAndValues

removeKey

getIfAbsentPutWith

getIfAbsent

getIfAbsentWith

ifPresentApply

forEachWith

updateValue

updateValueWith

toImmutable

Class ConcurrentHashMap<K,V>