Class ConcurrentHashMapUnsafe<K,V>

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.ConcurrentHashMapUnsafe<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 class ConcurrentHashMapUnsafe<K,V>
extends AbstractMutableMap<K,V>
implements ConcurrentMutableMap<K,V>, Externalizable

See Also:

• Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static final class	ConcurrentHashMapUnsafe.Entry<K,V>
private final class	ConcurrentHashMapUnsafe.EntryIterator
private final class	ConcurrentHashMapUnsafe.EntrySet
private class	ConcurrentHashMapUnsafe.HashIterator<E>
private static final class	ConcurrentHashMapUnsafe.IteratorState
private final class	ConcurrentHashMapUnsafe.KeyIterator
private final class	ConcurrentHashMapUnsafe.KeySet
private static final class	ConcurrentHashMapUnsafe.ResizeContainer
private final class	ConcurrentHashMapUnsafe.ValueIterator
private final class	ConcurrentHashMapUnsafe.Values

Nested classes/interfaces inherited from class AbstractMutableMap

AbstractMutableMap.ValuesCollectionCommon<V>

Field Summary

Fields

Modifier and Type	Field	Description
private static final int	DEFAULT_INITIAL_CAPACITY
private static final long	INT_ARRAY_BASE
private static final int	INT_ARRAY_SHIFT
private static final int	MAXIMUM_CAPACITY	The maximum capacity, used if a higher value is implicitly specified by either of the constructors with arguments.
private static final long	OBJECT_ARRAY_BASE
private static final int	OBJECT_ARRAY_SHIFT
private static final int	PARTITIONED_SIZE_THRESHOLD
private int[]	partitionedSize
private static final Object	RESIZE_SENTINEL
private static final Object	RESIZED
private static final Object	RESIZING
private static final long	serialVersionUID
private int	size
private static final int	SIZE_BUCKETS
private static final long	SIZE_OFFSET
private Object[]	table	The table, resized as necessary.
private static final AtomicReferenceFieldUpdater<ConcurrentHashMapUnsafe, Object[]>	TABLE_UPDATER
private static final sun.misc.Unsafe	UNSAFE

Constructor Summary

Constructors

Constructor	Description
ConcurrentHashMapUnsafe()
ConcurrentHashMapUnsafe(int initialCapacity)

Method Summary

Modifier and Type	Method	Description
private void	addToSize(int value)
private static Object	arrayAt(Object[] array, int index)
private static boolean	casArrayAt(Object[] array, int index, Object expected, Object newValue)
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)	Adds all the entries derived from iterable to this.
boolean	containsKey(Object key)
boolean	containsValue(Object value)
int	countEntries()
private ConcurrentHashMapUnsafe.Entry<K,V>	createReplacementChainForRemoval(ConcurrentHashMapUnsafe.Entry<K,V> original, ConcurrentHashMapUnsafe.Entry<K,V> toRemove)
Set<Map.Entry<K,V>>	entrySet()
boolean	equals(Object o)	Follows the same general contract as Map.equals(Object).
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)
private ConcurrentHashMapUnsafe.Entry<K,V>	getEntry(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.
private static sun.misc.Unsafe	getUnsafe()
private int	hash(Object key)
int	hashCode()	Follows the same general contract as Map.hashCode().
private Object[]	helpWithResize(Object[] currentArray)
private Object[]	helpWithResizeWhileCurrentIndex(Object[] currentArray, int index)
<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.
private void	incrementLocalSize(int value)
private boolean	incrementPartitionedSize(int value)
private void	incrementSizeAndPossiblyResize(Object[] currentArray, int length, Object prev)
private static int	indexFor(int h, int length)
boolean	isEmpty()	Returns true if this iterable has zero items.
Iterator<V>	iterator()
Set<K>	keySet()
V	merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)	A concurrent implementation of ConcurrentMap.merge(Object, Object, BiFunction) and Map.merge(Object, Object, BiFunction).
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> ConcurrentHashMapUnsafe<K,V>	newMap()
static <K,V> ConcurrentHashMapUnsafe<K,V>	newMap(int newSize)
static <NK,NV> ConcurrentHashMapUnsafe<NK,NV>	newMap(Map<NK,NV> map)
boolean	notEmpty()	The English equivalent of !this.isEmpty()
private boolean	nullSafeEquals(Object v, Object value)
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)	Remove an entry from the map at the specified key.
V	replace(K key, V value)
boolean	replace(K key, V oldValue, V newValue)
private void	resize(Object[] oldTable)
private void	resize(Object[] oldTable, int newSize)
private void	reverseTransfer(Object[] src, ConcurrentHashMapUnsafe.ResizeContainer resizeContainer)
private void	sequentialForEachKeyValue(Procedure2<? super K, ? super V> block, Object[] currentArray, int start, int end)
private void	sequentialForEachValue(Procedure<? super V> block, Object[] currentArray, int start, int end)
private void	sequentialPutAll(Object[] currentArray, int start, int end)
private static void	setArrayAt(Object[] array, int index, Object newValue)
int	size()	Returns the number of items in this iterable.
private V	slowGet(Object key, int hash, int index, Object[] currentArray)
private V	slowMerge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction, int hash, Object[] currentArray)
private V	slowPut(K key, V value, int hash, Object[] currentArray)
private V	slowRemove(Object key, int hash, Object[] currentArray)
private V	slowReplace(K key, V value, int hash, Object[] currentArray)
private boolean	slowReplace(K key, V oldValue, V newValue, int hash, Object[] currentArray)
private V	slowUpdateValue(K key, Function0<? extends V> factory, Function<? super V, ? extends V> function, int hash, Object[] currentArray)
private <P> V	slowUpdateValueWith(K key, Function0<? extends V> factory, Function2<? super V, ? super P, ? extends V> function, P parameter, int hash, Object[] currentArray)
ConcurrentMutableMap<K,V>	tap(Procedure<? super V> procedure)	Executes the Procedure for each element in the iterable and returns this.
ImmutableMap<K,V>	toImmutable()	Returns an immutable copy of this map.
String	toString()	Returns a string with the elements of the iterable separated by commas with spaces and enclosed in square brackets.
private void	transfer(Object[] src, ConcurrentHashMapUnsafe.ResizeContainer resizeContainer)
private void	unconditionalCopy(Object[] dest, ConcurrentHashMapUnsafe.Entry<K,V> toCopyEntry)
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 MutableMapIterable.updateValue(Object, Function0, Function) with a Function2 and specified parameter which is passed to the function.
Collection<V>	values()
ConcurrentHashMapUnsafe<K,V>	withAllKeyValueArguments(Pair<? extends K, ? extends V>... keyValues)	Convenience var-args version of withAllKeyValues
ConcurrentHashMapUnsafe<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.
ConcurrentHashMapUnsafe<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.
ConcurrentHashMapUnsafe<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.
ConcurrentHashMapUnsafe<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)

Methods inherited from class AbstractMutableMap

asSynchronized, asUnmodifiable, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectKeysUnique, collectLong, collectShort, collectValues, collectWith, flatCollect, flip, groupBy, groupByEach, groupByUniqueKey, partition, partitionWith, reject, reject, rejectWith, replaceAll, select, select, selectInstancesOf, selectWith, zip, zipWithIndex

Methods inherited from class AbstractMutableMapIterable

aggregateBy, collect, countBy, countByEach, countByWith, detect, detectOptional, flipUniqueValues, getIfAbsentPutWithKey, keysView, keyValuesView, reduceBy, sumByDouble, sumByFloat, sumByInt, sumByLong, valuesView

Methods inherited from class AbstractMapIterable

allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, asLazy, chunk, contains, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, getFirst, getIfAbsentValue, getLast, getOnly, getOrDefault, isAbsent, keyAndValueEquals, keyAndValueHashCode, noneSatisfy, noneSatisfyWith, toArray, toArray

Methods inherited from class 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 Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface ConcurrentMap

compute, computeIfAbsent, computeIfPresent, replaceAll

Methods inherited from interface ConcurrentMutableMap

forEach, getOrDefault, withMap, withMapIterable

Methods inherited from interface InternalIterable

forEach

Methods inherited from interface MapIterable

detect, detectOptional, getIfAbsentValue, injectIntoKeyValue, keysView, keyValuesView, parallelStream, spliterator, stream, valuesView

Methods inherited from interface MutableMap

aggregateBy, aggregateBy, aggregateInPlaceBy, asSynchronized, asUnmodifiable, collect, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectKeysUnique, collectLong, collectShort, collectValues, collectWith, flatCollect, flatCollectWith, flip, flipUniqueValues, groupBy, groupByEach, groupByUniqueKey, partition, partitionWith, reduceBy, reject, reject, rejectWith, select, select, selectInstancesOf, selectWith, zip, zipWithIndex

Methods inherited from interface MutableMapIterable

add, countBy, countByEach, countByWith, getIfAbsentPutWithKey, putAllMapIterable, putPair, removeAllKeys, removeIf, sumByDouble, sumByFloat, sumByInt, sumByLong

Methods inherited from interface 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, reduceBy, 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

Field Details

serialVersionUID

private static final long serialVersionUID

See Also:

• Constant Field Values

RESIZE_SENTINEL

private static final Object RESIZE_SENTINEL

DEFAULT_INITIAL_CAPACITY

private static final int DEFAULT_INITIAL_CAPACITY

See Also:

• Constant Field Values

MAXIMUM_CAPACITY

private static final int MAXIMUM_CAPACITY

The maximum capacity, used if a higher value is implicitly specified by either of the constructors with arguments. MUST be a power of two invalid input: '<'= 1invalid input: '<'invalid input: '<'30.

See Also:

• Constant Field Values

TABLE_UPDATER

private static final AtomicReferenceFieldUpdater<ConcurrentHashMapUnsafe, Object[]> TABLE_UPDATER

RESIZED

private static final Object RESIZED

RESIZING

private static final Object RESIZING

PARTITIONED_SIZE_THRESHOLD

private static final int PARTITIONED_SIZE_THRESHOLD

See Also:

• Constant Field Values

UNSAFE

private static final sun.misc.Unsafe UNSAFE

OBJECT_ARRAY_BASE

private static final long OBJECT_ARRAY_BASE

OBJECT_ARRAY_SHIFT

private static final int OBJECT_ARRAY_SHIFT

INT_ARRAY_BASE

private static final long INT_ARRAY_BASE

INT_ARRAY_SHIFT

private static final int INT_ARRAY_SHIFT

SIZE_OFFSET

private static final long SIZE_OFFSET

SIZE_BUCKETS

private static final int SIZE_BUCKETS

See Also:

• Constant Field Values

table

private volatile Object[] table

The table, resized as necessary. Length MUST Always be a power of two + 1.

partitionedSize

private int[] partitionedSize

size

private volatile int size

Constructor Details

ConcurrentHashMapUnsafe

public ConcurrentHashMapUnsafe()

ConcurrentHashMapUnsafe

public ConcurrentHashMapUnsafe(int initialCapacity)

Method Details

newMap

public static <K,V> ConcurrentHashMapUnsafe<K,V> newMap()

newMap

public static <K,V> ConcurrentHashMapUnsafe<K,V> newMap(int newSize)

arrayAt

private static Object arrayAt(Object[] array,
 int index)

casArrayAt

private static boolean casArrayAt(Object[] array,
 int index,
 Object expected,
 Object newValue)

setArrayAt

private static void setArrayAt(Object[] array,
 int index,
 Object newValue)

indexFor

private static int indexFor(int h,
 int length)

putIfAbsent

public V putIfAbsent(K key,
 V value)

Specified by:

putIfAbsent in interface ConcurrentMap<K,V>

Specified by:

putIfAbsent in interface Map<K,V>

incrementSizeAndPossiblyResize

private void incrementSizeAndPossiblyResize(Object[] currentArray,
 int length,
 Object prev)

hash

private int hash(Object key)

helpWithResizeWhileCurrentIndex

private Object[] helpWithResizeWhileCurrentIndex(Object[] currentArray,
 int index)

helpWithResize

private Object[] helpWithResize(Object[] currentArray)

resize

private void resize(Object[] oldTable)

resize

private void resize(Object[] oldTable,
 int newSize)

transfer

private void transfer(Object[] src,
 ConcurrentHashMapUnsafe.ResizeContainer resizeContainer)

reverseTransfer

private void reverseTransfer(Object[] src,
 ConcurrentHashMapUnsafe.ResizeContainer resizeContainer)

unconditionalCopy

private void unconditionalCopy(Object[] dest,
 ConcurrentHashMapUnsafe.Entry<K,V> toCopyEntry)

countEntries

public int countEntries()

getIfAbsentPut

public V getIfAbsentPut(K key,
 Function<? super K, ? extends V> factory)

getIfAbsentPut

public V getIfAbsentPut(K key,
 Function0<? extends V> factory)

Description copied from interface: MutableMapIterable

Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map at the key, return the result of evaluating the specified Function0, and put that value in the map at the specified key.

Specified by:

getIfAbsentPut in interface MutableMapIterable<K,V>

Overrides:

getIfAbsentPut in class AbstractMutableMapIterable<K,V>

getIfAbsentPut

public V getIfAbsentPut(K key,
 V value)

Description copied from interface: MutableMapIterable

Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map at the key, return the specified value, and put that value in the map at the specified key.

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>

addToSize

private void addToSize(int value)

incrementPartitionedSize

private boolean incrementPartitionedSize(int value)

incrementLocalSize

private void incrementLocalSize(int value)

size

public int size()

Description copied from interface: RichIterable

Returns the number of items in this iterable.

Specified by:

size in interface Map<K,V>

Specified by:

size in interface RichIterable<K>

isEmpty

public boolean isEmpty()

Description copied from interface: RichIterable

Returns true if this iterable has zero items.

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>

See Also:

• Map.containsKey(Object)

containsValue

public boolean containsValue(Object value)

Specified by:

containsValue in interface Map<K,V>

Specified by:

containsValue in interface MapIterable<K,V>

See Also:

• Map.containsValue(Object)

nullSafeEquals

private boolean nullSafeEquals(Object v,
 Object value)

get

public V get(Object key)

Specified by:

get in interface Map<K,V>

Specified by:

get in interface MapIterable<K,V>

See Also:

• Map.get(Object)

slowGet

private V slowGet(Object key,
 int hash,
 int index,
 Object[] currentArray)

getEntry

private ConcurrentHashMapUnsafe.Entry<K,V> getEntry(Object key)

put

public V put(K key,
 V value)

Specified by:

put in interface Map<K,V>

slowPut

private V slowPut(K key,
 V value,
 int hash,
 Object[] currentArray)

putAllInParallel

public void putAllInParallel(Map<? extends K, ? extends V> map,
 int chunks,
 Executor executor)

sequentialPutAll

private void sequentialPutAll(Object[] currentArray,
 int start,
 int end)

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>

slowReplace

private boolean slowReplace(K key,
 V oldValue,
 V newValue,
 int hash,
 Object[] currentArray)

replace

public V replace(K key,
 V value)

Specified by:

replace in interface ConcurrentMap<K,V>

Specified by:

replace in interface Map<K,V>

slowReplace

private V slowReplace(K key,
 V value,
 int hash,
 Object[] currentArray)

remove

public V remove(Object key)

Specified by:

remove in interface Map<K,V>

slowRemove

private V slowRemove(Object key,
 int hash,
 Object[] currentArray)

createReplacementChainForRemoval

private ConcurrentHashMapUnsafe.Entry<K,V> createReplacementChainForRemoval(ConcurrentHashMapUnsafe.Entry<K,V> original,
 ConcurrentHashMapUnsafe.Entry<K,V> toRemove)

parallelForEachKeyValue

public void parallelForEachKeyValue(List<Procedure2<K,V>> blocks,
 Executor executor)

sequentialForEachKeyValue

private void sequentialForEachKeyValue(Procedure2<? super K, ? super V> block,
 Object[] currentArray,
 int start,
 int end)

parallelForEachValue

public void parallelForEachValue(List<Procedure<V>> blocks,
 Executor executor)

sequentialForEachValue

private void sequentialForEachValue(Procedure<? super V> block,
 Object[] currentArray,
 int start,
 int end)

hashCode

public int hashCode()

Description copied from interface: MapIterable

Follows the same general contract as Map.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)

Description copied from interface: MapIterable

Follows the same general contract as Map.equals(Object).

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>
ConcurrentHashMapUnsafe<NK,NV> newMap(Map<NK,NV> map)

withKeyValue

public ConcurrentHashMapUnsafe<K,V> withKeyValue(K key,
 V value)

Description copied from interface: MutableMapIterable

This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing elements. In order to support fixed size maps, a new instance of a map would have to be returned including the keys and values of the original plus the additional key and value. In the case of mutable maps, the original map is modified and then returned. In order to use this method properly with mutable and fixed size maps the following approach must be taken:

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.

Specified by:

withKeyValue in interface MutableMap<K,V>

Specified by:

withKeyValue in interface MutableMapIterable<K,V>

Overrides:

withKeyValue in class AbstractMutableMap<K,V>

See Also:

• Map.put(Object, Object)

withAllKeyValues

public ConcurrentHashMapUnsafe<K,V> withAllKeyValues(Iterable<? extends Pair<? extends K, ? extends V>> keyValues)

Description copied from interface: MutableMapIterable

This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing elements. In order to support fixed size maps, a new instance of a map would have to be returned including the keys and values of the original plus all the additional keys and values. In the case of mutable maps, the original map is modified and then returned. In order to use this method properly with mutable and fixed size maps the following approach must be taken:

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.

Specified by:

withAllKeyValues in interface MutableMap<K,V>

Specified by:

withAllKeyValues in interface MutableMapIterable<K,V>

Overrides:

withAllKeyValues in class AbstractMutableMap<K,V>

See Also:

• Map.put(Object, Object)

withAllKeyValueArguments

public ConcurrentHashMapUnsafe<K,V> withAllKeyValueArguments(Pair<? extends K, ? extends V>... keyValues)

Description copied from interface: MutableMapIterable

Convenience var-args version of withAllKeyValues

Specified by:

withAllKeyValueArguments in interface MutableMap<K,V>

Specified by:

withAllKeyValueArguments in interface MutableMapIterable<K,V>

Overrides:

withAllKeyValueArguments in class AbstractMutableMap<K,V>

See Also:

• MutableMapIterable.withAllKeyValues(Iterable)

withoutKey

public ConcurrentHashMapUnsafe<K,V> withoutKey(K key)

Description copied from interface: MutableMapIterable

This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing elements. In order to support fixed size maps, a new instance of a map would have to be returned including the keys and values of the original minus the key and value to be removed. In the case of mutable maps, the original map is modified and then returned. In order to use this method properly with mutable and fixed size maps the following approach must be taken:

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.

Specified by:

withoutKey in interface MutableMap<K,V>

Specified by:

withoutKey in interface MutableMapIterable<K,V>

Overrides:

withoutKey in class AbstractMutableMap<K,V>

See Also:

• Map.remove(Object)

withoutAllKeys

public ConcurrentHashMapUnsafe<K,V> withoutAllKeys(Iterable<? extends K> keys)

Description copied from interface: MutableMapIterable

This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing elements. In order to support fixed size maps, a new instance of a map would have to be returned including the keys and values of the original minus all the keys and values to be removed. In the case of mutable maps, the original map is modified and then returned. In order to use this method properly with mutable and fixed size maps the following approach must be taken:

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.

Specified by:

withoutAllKeys in interface MutableMap<K,V>

Specified by:

withoutAllKeys in interface MutableMapIterable<K,V>

Overrides:

withoutAllKeys in class AbstractMutableMap<K,V>

See Also:

• Map.remove(Object)

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()

Description copied from interface: RichIterable

The English equivalent of !this.isEmpty()

Specified by:

notEmpty in interface RichIterable<K>

forEachWithIndex

public void forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure)

Description copied from interface: InternalIterable

Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure.

Example using a Java 8 lambda:

people.forEachWithIndex((Person person, int index) -> LOGGER.info("Index: " + index + " person: " + person.getName()));

Example using an anonymous inner class:

people.forEachWithIndex(new ObjectIntProcedure<Person>()
{
    public void value(Person person, int index)
    {
        LOGGER.info("Index: " + index + " person: " + person.getName());
    }
});

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()

Description copied from interface: MutableMapIterable

Creates a new instance of the same type, using the default capacity and growth parameters.

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)

Description copied from interface: RichIterable

Executes the Procedure for each element in the iterable and returns this.

Example using a Java 8 lambda expression:

RichIterable<Person> tapped =
    people.tap(person -> LOGGER.info(person.getName()));

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>

See Also:

• RichIterable.each(Procedure)
• RichIterable.forEach(Procedure)

forEachValue

public void forEachValue(Procedure<? super V> procedure)

Description copied from interface: MapIterable

Calls the procedure with each value of the map.

    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);

Specified by:

forEachValue in interface MapIterable<K,V>

Overrides:

forEachValue in class AbstractMapIterable<K,V>

forEachKey

public void forEachKey(Procedure<? super K> procedure)

Description copied from interface: MapIterable

Calls the procedure 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);

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)

Description copied from interface: MapIterable

Calls the procedure 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((Integer key, String value) -> collection.add(String.valueOf(key) + value));
    Verify.assertContainsAll(collection, "1One", "2Two", "3Three");

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)

Description copied from interface: MutableMap

Adds all the entries derived from iterable 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 its value replaced by that in map.

Specified by:

collectKeysAndValues in interface MutableMap<K,V>

removeKey

public V removeKey(K key)

Description copied from interface: MutableMapIterable

Remove an entry from the map at the specified key.

Specified by:

removeKey in interface MutableMapIterable<K,V>

Returns:

The value removed from entry at key, or null if not found.

See Also:

• Map.remove(Object)

getIfAbsentPutWith

public <P> V getIfAbsentPutWith(K key,
 Function<? super P, ? extends V> function,
 P parameter)

Description copied from interface: MutableMapIterable

Get and return the value in the Map at the specified key. Alternatively, if there is no value in the map for that key return the result of evaluating the specified Function using the specified parameter, and put that value in the map at the specified key.

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)

Description copied from interface: MapIterable

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.

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)

Description copied from interface: MapIterable

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.

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)

Description copied from interface: MapIterable

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.

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)

Description copied from interface: InternalIterable

The procedure2 is evaluated for each element in the iterable with the specified parameter provided as the second argument.

Example using a Java 8 lambda:

people.forEachWith((Person person, Person other) ->
    {
        if (person.isRelatedTo(other))
        {
             LOGGER.info(person.getName());
        }
    }, fred);

Example using an anonymous inner class:

people.forEachWith(new Procedure2<Person, Person>()
{
    public void value(Person person, Person other)
    {
        if (person.isRelatedTo(other))
        {
             LOGGER.info(person.getName());
        }
    }
}, fred);

Specified by:

forEachWith in interface InternalIterable<K>

Overrides:

forEachWith in class AbstractMapIterable<K,V>

getUnsafe

private static sun.misc.Unsafe getUnsafe()

updateValue

public V updateValue(K key,
 Function0<? extends V> factory,
 Function<? super V, ? extends V> function)

Description copied from interface: MutableMapIterable

Looks up the value associated with key, applies the function to it, and replaces the value. If there is no value associated with key, starts it off with a value supplied by factory.

Specified by:

updateValue in interface MutableMapIterable<K,V>

Overrides:

updateValue in class AbstractMutableMapIterable<K,V>

slowUpdateValue

private V slowUpdateValue(K key,
 Function0<? extends V> factory,
 Function<? super V, ? extends V> function,
 int hash,
 Object[] currentArray)

updateValueWith

public <P> V updateValueWith(K key,
 Function0<? extends V> factory,
 Function2<? super V, ? super P, ? extends V> function,
 P parameter)

Description copied from interface: MutableMapIterable

Same as MutableMapIterable.updateValue(Object, Function0, Function) with a Function2 and specified parameter which is passed to the function.

Specified by:

updateValueWith in interface MutableMapIterable<K,V>

Overrides:

updateValueWith in class AbstractMutableMapIterable<K,V>

slowUpdateValueWith

private <P> V slowUpdateValueWith(K key,
 Function0<? extends V> factory,
 Function2<? super V, ? super P, ? extends V> function,
 P parameter,
 int hash,
 Object[] currentArray)

merge

public V merge(K key,
 V value,
 BiFunction<? super V, ? super V, ? extends V> remappingFunction)

Description copied from interface: ConcurrentMutableMap

A concurrent implementation of ConcurrentMap.merge(Object, Object, BiFunction) and Map.merge(Object, Object, BiFunction). In the implementing classes, it is possible for the remappingFunction to be called multiple times. It is also possible for the remappingFunction to be called one or more times, but the result is not used (because the old entry was concurrently removed).

Specified by:

merge in interface ConcurrentMap<K,V>

Specified by:

merge in interface ConcurrentMutableMap<K,V>

Specified by:

merge in interface Map<K,V>

slowMerge

private V slowMerge(K key,
 V value,
 BiFunction<? super V, ? super V, ? extends V> remappingFunction,
 int hash,
 Object[] currentArray)

toImmutable

public ImmutableMap<K,V> toImmutable()

Description copied from interface: MutableMapIterable

Returns an immutable copy of this map. If the map is immutable, it returns itself.

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>