public final class ConcurrentHashMap<K,V> extends AbstractMutableMap<K,V> implements ConcurrentMutableMap<K,V>, Externalizable
| Constructor and Description |
|---|
ConcurrentHashMap() |
ConcurrentHashMap(int initialCapacity) |
| Modifier and Type | Method and Description |
|---|---|
void |
clear() |
MutableMap<K,V> |
clone()
Returns a string representation of this map.
|
<E> MutableMap<K,V> |
collectKeysAndValues(Iterable<E> iterable,
Function<? super E,? extends K> keyFunction,
Function<? super E,? extends V> valueFunction)
Adds all the entries derived from
collection to this. |
boolean |
containsKey(Object key) |
boolean |
containsValue(Object value) |
Set<Map.Entry<K,V>> |
entrySet() |
boolean |
equals(Object o)
Follows the same general contract as
Map.equals(Object). |
void |
forEach(Procedure<? super V> procedure)
The procedure is executed for each element in the iterable.
|
void |
forEachKey(Procedure<? super K> procedure)
Calls the
procedure with each key of the map. |
void |
forEachKeyValue(Procedure2<? super K,? super V> procedure)
Calls the
procedure with each key-value pair of the map. |
void |
forEachValue(Procedure<? super V> procedure)
Calls the procedure with each value of the map.
|
<P> void |
forEachWith(Procedure2<? super V,? super P> procedure,
P parameter)
The procedure2 is evaluated for each element in the iterable with the specified parameter provided
as the second argument.
|
void |
forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure)
Iterates over the iterable passing each element and the current relative int index to the specified instance of
ObjectIntProcedure
|
V |
get(Object key) |
V |
getIfAbsent(K key,
Function0<? extends V> function)
Return the value in the Map that corresponds to the specified key, or if there is no value at the key, return the
result of evaluating the specified Function0.
|
V |
getIfAbsentPut(K key,
Function<? super K,? extends V> factory) |
V |
getIfAbsentPut(K key,
Function0<? extends V> factory)
Get and return the value in the Map at the specified key.
|
V |
getIfAbsentPut(K key,
V value)
Get and return the value in the Map at the specified key.
|
<P> V |
getIfAbsentPutWith(K key,
Function<? super P,? extends V> function,
P parameter)
Get and return the value in the Map at the specified key.
|
<P> V |
getIfAbsentWith(K key,
Function<? super P,? extends V> function,
P parameter)
Return the value in the Map that corresponds to the specified key, or if there is no value at the key, return the
result of evaluating the specified function and parameter.
|
int |
hashCode()
Follows the same general contract as
Map.hashCode(). |
<A> A |
ifPresentApply(K key,
Function<? super V,? extends A> function)
If there is a value in the Map that corresponds to the specified key return the result of applying the specified
Function on the value, otherwise return null.
|
boolean |
isEmpty()
Returns true if this iterable has zero items.
|
Iterator<V> |
iterator() |
Set<K> |
keySet() |
MutableMap<K,V> |
newEmpty()
Creates a new instance of the same type, using the default capacity and growth parameters.
|
<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()
The English equivalent of !this.isEmpty()
|
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<K,V> map,
int chunks,
Executor executor) |
V |
putIfAbsent(K key,
V value) |
<P1,P2> V |
putIfAbsentGetIfPresent(K key,
Function2<K,V,K> keyTransformer,
Function3<P1,P2,K,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)
Remove an entry from the map at the specified
key. |
V |
replace(K key,
V value) |
boolean |
replace(K key,
V oldValue,
V newValue) |
int |
size()
Returns the number of items in this iterable.
|
ImmutableMap<K,V> |
toImmutable()
Returns an immutable copy of this map.
|
String |
toString()
Returns a string representation of this MapIterable.
|
V |
updateValue(K key,
Function0<? extends V> factory,
Function<? super V,? extends V> function)
Looks up the value associated with
key, applies the function to it, and replaces the value. |
<P> V |
updateValueWith(K key,
Function0<? extends V> factory,
Function2<? super V,? super P,? extends V> function,
P parameter)
Same as
MutableMap.updateValue(Object, Function0, Function) with a Function2 and specified parameter which is
passed to the function. |
Collection<V> |
values() |
ConcurrentHashMap<K,V> |
withAllKeyValueArguments(Pair<? extends K,? extends V>... keyValues)
Convenience var-args version of withAllKeyValues
|
ConcurrentHashMap<K,V> |
withAllKeyValues(Iterable<? extends Pair<? extends K,? extends V>> keyValues)
This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing
elements.
|
ConcurrentHashMap<K,V> |
withKeyValue(K key,
V value)
This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing
elements.
|
ConcurrentHashMap<K,V> |
withoutAllKeys(Iterable<? extends K> keys)
This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing
elements.
|
ConcurrentHashMap<K,V> |
withoutKey(K key)
This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing
elements.
|
void |
writeExternal(ObjectOutput out) |
add, aggregateBy, aggregateInPlaceBy, asSynchronized, asUnmodifiable, collect, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectValues, collectWith, detect, flatCollect, flip, flipUniqueValues, getIfAbsentPutWithKey, groupBy, groupByEach, groupByUniqueKey, keysView, keyValuesView, partition, partitionWith, reject, reject, select, select, selectInstancesOf, selectWith, valuesView, zip, zipWithIndexallSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, flatCollect, getFirst, getIfAbsentValue, getLast, groupBy, groupByEach, injectInto, injectInto, injectInto, injectInto, injectInto, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, reject, rejectWith, rejectWith, select, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndexadd, aggregateBy, aggregateInPlaceBy, asSynchronized, asUnmodifiable, collect, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectValues, flatCollect, flip, flipUniqueValues, getIfAbsentPutWithKey, groupBy, groupByEach, groupByUniqueKey, partition, partitionWith, reject, reject, select, select, selectInstancesOf, zip, zipWithIndexdetect, getIfAbsentValue, keysView, keyValuesView, valuesViewallSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, flatCollect, getFirst, getLast, groupBy, groupByEach, injectInto, injectInto, injectInto, injectInto, injectInto, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, reject, rejectWith, rejectWith, select, selectWith, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndexforEach, spliteratorcompute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAllpublic ConcurrentHashMap()
public ConcurrentHashMap(int initialCapacity)
public static <K,V> ConcurrentHashMap<K,V> newMap()
public static <K,V> ConcurrentHashMap<K,V> newMap(int newSize)
public V putIfAbsent(K key, V value)
putIfAbsent in interface ConcurrentMap<K,V>putIfAbsent in interface Map<K,V>public V getIfAbsentPut(K key, Function0<? extends V> factory)
MutableMapgetIfAbsentPut in interface MutableMap<K,V>getIfAbsentPut in class AbstractMutableMap<K,V>public V getIfAbsentPut(K key, V value)
MutableMapgetIfAbsentPut in interface MutableMap<K,V>getIfAbsentPut in class AbstractMutableMap<K,V>public <P1,P2> V putIfAbsentGetIfPresent(K key, Function2<K,V,K> keyTransformer, Function3<P1,P2,K,V> factory, P1 param1, P2 param2)
key - The "mutable" key, which has the same identity/hashcode as the inserted key, only during this callkeyTransformer - 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.public int size()
RichIterablepublic boolean isEmpty()
RichIterablepublic boolean containsKey(Object key)
containsKey in interface MapIterable<K,V>containsKey in interface Map<K,V>Map.containsKey(Object)public boolean containsValue(Object value)
containsValue in interface MapIterable<K,V>containsValue in interface Map<K,V>Map.containsValue(Object)public V get(Object key)
get in interface MapIterable<K,V>get in interface Map<K,V>Map.get(Object)public void parallelForEachKeyValue(List<Procedure2<K,V>> blocks, Executor executor)
public int hashCode()
MapIterableMap.hashCode().public boolean equals(Object o)
MapIterableMap.equals(Object).public String toString()
MapIterableString.valueOf(Object).toString in interface MapIterable<K,V>toString in interface RichIterable<V>toString in class Objectpublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
readExternal in interface ExternalizableIOExceptionClassNotFoundExceptionpublic void writeExternal(ObjectOutput out) throws IOException
writeExternal in interface ExternalizableIOExceptionpublic static <NK,NV> ConcurrentHashMap<NK,NV> newMap(Map<NK,NV> map)
public ConcurrentHashMap<K,V> withKeyValue(K key, V value)
MutableMap
map = map.withKeyValue("new key", "new value");
In the case of FixedSizeMap, a new instance will be returned by withKeyValue, and any variables that
previously referenced the original map will need to be redirected to reference the new instance. In the case
of a FastMap or UnifiedMap, you will be replacing the reference to map with map, since FastMap and UnifiedMap
will both return "this" after calling put on themselves.withKeyValue in interface MutableMap<K,V>withKeyValue in class AbstractMutableMap<K,V>Map.put(Object, Object)public ConcurrentHashMap<K,V> withAllKeyValues(Iterable<? extends Pair<? extends K,? extends V>> keyValues)
MutableMap
map = map.withAllKeyValues(FastList.newListWith(PairImpl.of("new key", "new value")));
In the case of FixedSizeMap, a new instance will be returned by withAllKeyValues, and any variables that
previously referenced the original map will need to be redirected to reference the new instance. In the case
of a FastMap or UnifiedMap, you will be replacing the reference to map with map, since FastMap and UnifiedMap
will both return "this" after calling put on themselves.withAllKeyValues in interface MutableMap<K,V>withAllKeyValues in class AbstractMutableMap<K,V>Map.put(Object, Object)public ConcurrentHashMap<K,V> withAllKeyValueArguments(Pair<? extends K,? extends V>... keyValues)
MutableMapwithAllKeyValueArguments in interface MutableMap<K,V>withAllKeyValueArguments in class AbstractMutableMap<K,V>MutableMap.withAllKeyValues(Iterable)public ConcurrentHashMap<K,V> withoutKey(K key)
MutableMap
map = map.withoutKey("key");
In the case of FixedSizeMap, a new instance will be returned by withoutKey, and any variables that previously
referenced the original map will need to be redirected to reference the new instance. In the case of a FastMap
or UnifiedMap, you will be replacing the reference to map with map, since FastMap and UnifiedMap will both return
"this" after calling remove on themselves.withoutKey in interface MutableMap<K,V>withoutKey in class AbstractMutableMap<K,V>Map.remove(Object)public ConcurrentHashMap<K,V> withoutAllKeys(Iterable<? extends K> keys)
MutableMap
map = map.withoutAllKeys(FastList.newListWith("key1", "key2"));
In the case of FixedSizeMap, a new instance will be returned by withoutAllKeys, and any variables that previously
referenced the original map will need to be redirected to reference the new instance. In the case of a FastMap
or UnifiedMap, you will be replacing the reference to map with map, since FastMap and UnifiedMap will both return
"this" after calling remove on themselves.withoutAllKeys in interface MutableMap<K,V>withoutAllKeys in class AbstractMutableMap<K,V>Map.remove(Object)public MutableMap<K,V> clone()
AbstractMutableMapThis implementation creates an empty string buffer, appends a left brace, and iterates over the map's entrySet view, appending the string representation of each map.entry in turn. After appending each entry except the last, the string ", " is appended. Finally a right brace is appended. A string is obtained from the stringbuffer, and returned.
clone in interface MutableMap<K,V>clone in class AbstractMutableMap<K,V>public <K,V> MutableMap<K,V> newEmpty(int capacity)
AbstractMutableMapnewEmpty in class AbstractMutableMap<K,V>public boolean notEmpty()
RichIterablenotEmpty in interface RichIterable<V>notEmpty in class AbstractMapIterable<K,V>public void forEach(Procedure<? super V> procedure)
InternalIterablee.g. people.forEach(new Procedure() { public void value(Person person) { LOGGER.info(person.getName()); } });
forEach in interface InternalIterable<V>forEach in class AbstractMapIterable<K,V>public void forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure)
InternalIterablee.g. people.forEachWithIndex(new ObjectIntProcedure() { public void value(Person person, int index) { LOGGER.info("Index: " + index + " person: " + person.getName()); } });
forEachWithIndex in interface InternalIterable<V>forEachWithIndex in class AbstractMapIterable<K,V>public MutableMap<K,V> newEmpty()
MutableMapnewEmpty in interface MutableMap<K,V>public void forEachValue(Procedure<? super V> procedure)
MapIterable
Set<String> result = UnifiedSet.newSet();
MutableMap<Integer, String> map = this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three", 4, "Four");
map.forEachValue(new CollectionAddProcedure<String>(result));
Verify.assertSetsEqual(UnifiedSet.newSetWith("One", "Two", "Three", "Four"), result);
forEachValue in interface MapIterable<K,V>forEachValue in class AbstractMapIterable<K,V>public void forEachKey(Procedure<? super K> procedure)
MapIterableprocedure with each key of the map.
final Collection<Integer> result = new ArrayList<Integer>();
MutableMap<Integer, String> map = this.newMapWithKeysValues(1, "1", 2, "2", 3, "3");
map.forEachKey(new CollectionAddProcedure<Integer>(result));
Verify.assertContainsAll(result, 1, 2, 3);
forEachKey in interface MapIterable<K,V>forEachKey in class AbstractMapIterable<K,V>public void forEachKeyValue(Procedure2<? super K,? super V> procedure)
MapIterableprocedure with each key-value pair of the map.
final Collection<String> collection = new ArrayList<String>();
MutableMap<Integer, String> map = this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue(new Procedure2<Integer, String>()
{
public void value(final Integer key, final String value)
{
collection.add(String.valueOf(key) + value);
}
});
Verify.assertContainsAll(collection, "1One", "2Two", "3Three");
forEachKeyValue in interface MapIterable<K,V>public <E> MutableMap<K,V> collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)
MutableMapcollection to this. The key and value for each entry
is determined by applying the keyFunction and valueFunction to each item in
collection. Any entry in map that has the same key as an entry in this
will have it's value replaced by that in map.collectKeysAndValues in interface MutableMap<K,V>public V removeKey(K key)
MutableMapkey.removeKey in interface MutableMap<K,V>Map.remove(Object)public <P> V getIfAbsentPutWith(K key, Function<? super P,? extends V> function, P parameter)
MutableMapgetIfAbsentPutWith in interface MutableMap<K,V>getIfAbsentPutWith in class AbstractMutableMap<K,V>public V getIfAbsent(K key, Function0<? extends V> function)
MapIterablegetIfAbsent in interface MapIterable<K,V>getIfAbsent in class AbstractMapIterable<K,V>public <P> V getIfAbsentWith(K key, Function<? super P,? extends V> function, P parameter)
MapIterablegetIfAbsentWith in interface MapIterable<K,V>getIfAbsentWith in class AbstractMapIterable<K,V>public <A> A ifPresentApply(K key, Function<? super V,? extends A> function)
MapIterableifPresentApply in interface MapIterable<K,V>ifPresentApply in class AbstractMapIterable<K,V>public <P> void forEachWith(Procedure2<? super V,? super P> procedure, P parameter)
InternalIterable