Eclipse Collections 13.0.0 · org.eclipse.collections.impl.map.mutable.ConcurrentHashMapUnsafe

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

Modifier and Type	Field and 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 volatile int	size
private static final int	SIZE_BUCKETS
private static final long	SIZE_OFFSET
private volatile Object[]	table The table, resized as necessary.
private static final AtomicReferenceFieldUpdater<ConcurrentHashMapUnsafe<K, V>, Object[]>	TABLE_UPDATER
private static final Unsafe	UNSAFE

Access	Constructor and Description
public	ConcurrentHashMapUnsafe()
public	ConcurrentHashMapUnsafe(int initialCapacity)

Method Summary

Modifier and Type	Method and 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)
public void	clear() Implements java.util.Map.clear. Removes all of the mappings from this map (optional operation).
public MutableMap<K, V>	clone() Implements abstract org.eclipse.collections.impl.map.mutable.AbstractMutableMap.clone. Implements org.eclipse.collections.api.map.MutableMap.clone. Creates and returns a copy of this object.
public <E> MutableMap<K, V>	collectKeysAndValues(Iterable<E> iterable, Function<? super E, ? extends K> keyFunction, Function<? super E, ? extends V> valueFunction) Implements org.eclipse.collections.api.map.MutableMap.collectKeysAndValues. Adds all the entries derived from `iterable` to `this`.
public boolean	containsKey(Object key) Implements org.eclipse.collections.api.map.MapIterable.containsKey, java.util.Map.containsKey. Returns `true` if this map contains a mapping for the specified key.
public boolean	containsValue(Object value) Implements org.eclipse.collections.api.map.MapIterable.containsValue, java.util.Map.containsValue. Returns `true` if this map maps one or more keys to the specified value.
public int	countEntries()
private ConcurrentHashMapUnsafe.Entry<K, V>	createReplacementChainForRemoval(ConcurrentHashMapUnsafe.Entry<K, V> original, ConcurrentHashMapUnsafe.Entry<K, V> toRemove)
public Set<Map.Entry<K, V>>	entrySet() Implements java.util.Map.entrySet. Returns a `Set` view of the mappings contained in this map.
public boolean	equals(Object o) Overrides java.lang.Object.equals. Implements org.eclipse.collections.api.map.MapIterable.equals, java.util.Map.equals. Follows the same general contract as `Map#equals(Object)`.
public void	forEachKey(Procedure<? super K> procedure) Overrides org.eclipse.collections.impl.map.AbstractMapIterable.forEachKey. Implements org.eclipse.collections.api.map.MapIterable.forEachKey. Calls the `procedure` with each key of the map.
public void	forEachKeyValue(Procedure2<? super K, ? super V> procedure) Implements org.eclipse.collections.api.map.MapIterable.forEachKeyValue. Calls the `procedure` with each key-value pair of the map.
public void	forEachValue(Procedure<? super V> procedure) Overrides org.eclipse.collections.impl.map.AbstractMapIterable.forEachValue. Implements org.eclipse.collections.api.map.MapIterable.forEachValue. Calls the procedure with each value of the map.
public <P> void	forEachWith(Procedure2<? super V, ? super P> procedure, P parameter) Overrides org.eclipse.collections.impl.map.AbstractMapIterable.forEachWith. Implements org.eclipse.collections.api.InternalIterable.forEachWith. The procedure2 is evaluated for each element in the iterable with the specified parameter provided as the second argument.
public void	forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure) Overrides org.eclipse.collections.impl.map.AbstractMapIterable.forEachWithIndex. Implements org.eclipse.collections.api.InternalIterable.forEachWithIndex. Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure.
public V	get(Object key) Implements org.eclipse.collections.api.map.MapIterable.get, java.util.Map.get. Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key.
private ConcurrentHashMapUnsafe.Entry<K, V>	getEntry(Object key)
public V	getIfAbsent(K key, Function0<? extends V> function) Overrides org.eclipse.collections.impl.map.AbstractMapIterable.getIfAbsent. Implements org.eclipse.collections.api.map.MapIterable.getIfAbsent. 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.
public V	getIfAbsentPut(K key, Function<? super K, ? extends V> factory) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable.getIfAbsentPut. Implements org.eclipse.collections.api.map.MutableMapIterable.getIfAbsentPut. Get and return the value in the Map at the specified key.
public V	getIfAbsentPut(K key, Function0<? extends V> factory) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable.getIfAbsentPut, org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable.getIfAbsentPut. Implements org.eclipse.collections.api.map.MutableMapIterable.getIfAbsentPut, org.eclipse.collections.api.map.MutableMapIterable.getIfAbsentPut. Get and return the value in the Map at the specified key.
public V	getIfAbsentPut(K key, V value) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable.getIfAbsentPut. Implements org.eclipse.collections.api.map.MutableMapIterable.getIfAbsentPut. Get and return the value in the Map at the specified key.
public <P> V	getIfAbsentPutWith(K key, Function<? super P, ? extends V> function, P parameter) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable.getIfAbsentPutWith. Implements org.eclipse.collections.api.map.MutableMapIterable.getIfAbsentPutWith. Get and return the value in the Map at the specified key.
public <P> V	getIfAbsentWith(K key, Function<? super P, ? extends V> function, P parameter) Overrides org.eclipse.collections.impl.map.AbstractMapIterable.getIfAbsentWith. Implements org.eclipse.collections.api.map.MapIterable.getIfAbsentWith. 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 Unsafe	getUnsafe()
private int	hash(Object key)
public int	hashCode() Overrides java.lang.Object.hashCode. Implements org.eclipse.collections.api.map.MapIterable.hashCode, java.util.Map.hashCode. Follows the same general contract as `Map#hashCode()`.
private Object[]	helpWithResize(Object[] currentArray)
private Object[]	helpWithResizeWhileCurrentIndex(Object[] currentArray, int index)
public <A> A	ifPresentApply(K key, Function<? super V, ? extends A> function) Overrides org.eclipse.collections.impl.map.AbstractMapIterable.ifPresentApply. Implements org.eclipse.collections.api.map.MapIterable.ifPresentApply. 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)
public boolean	isEmpty() Overrides org.eclipse.collections.impl.AbstractRichIterable.isEmpty. Implements org.eclipse.collections.api.RichIterable.isEmpty, java.util.Map.isEmpty. Returns `true` if this map contains no key-value mappings.
public Iterator<V>	iterator() Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable.iterator. Implements java.lang.Iterable.iterator. Returns an iterator over elements of type `T`.
public Set<K>	keySet() Implements java.util.Map.keySet. Returns a `Set` view of the keys contained in this map.
public V	merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) Overrides default java.util.Map.merge. Implements org.eclipse.collections.api.map.ConcurrentMutableMap.merge. A concurrent implementation of `ConcurrentMap#merge(Object, Object, BiFunction)` and `Map#merge(Object, Object, BiFunction)`.
public <K, V> MutableMap<K, V>	newEmpty(int capacity) Implements abstract org.eclipse.collections.impl.map.mutable.AbstractMutableMap.newEmpty. Creates a new instance of the same type, using the given capacity and the default growth parameters.
public MutableMap<K, V>	newEmpty() Implements org.eclipse.collections.api.map.MutableMap.newEmpty, org.eclipse.collections.api.map.MutableMapIterable.newEmpty. Creates a new instance of the same type, using the default capacity and growth parameters.
public static <K, V> ConcurrentHashMapUnsafe<K, V>	newMap()
public static <K, V> ConcurrentHashMapUnsafe<K, V>	newMap(int newSize)
public static <NK, NV> ConcurrentHashMapUnsafe<NK, NV>	newMap(Map<NK, NV> map)
public boolean	notEmpty() Overrides default org.eclipse.collections.api.RichIterable.notEmpty. The English equivalent of !this.isEmpty()
private boolean	nullSafeEquals(Object v, Object value)
public void	parallelForEachKeyValue(List<Procedure2<K, V>> blocks, Executor executor)
public void	parallelForEachValue(List<Procedure<V>> blocks, Executor executor)
public V	put(K key, V value) Implements java.util.Map.put. Associates the specified value with the specified key in this map (optional operation).
public void	putAll(Map<? extends K, ? extends V> map) Implements java.util.Map.putAll. Copies all of the mappings from the specified map to this map (optional operation).
public void	putAllInParallel(Map<? extends K, ? extends V> map, int chunks, Executor executor)
public V	putIfAbsent(K key, V value) Overrides default java.util.Map.putIfAbsent. Implements java.util.concurrent.ConcurrentMap.putIfAbsent. If the specified key is not already associated with a value, associates it with the given value.
public <P1, P2> V	putIfAbsentGetIfPresent(K The "mutable" key, which has the same identity/hashcode as the inserted key, only during this call key, Function2<? super K, ? super V, ? extends K> 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. keyTransformer, Function3<P1, P2, ? super K, ? extends V> It creates an object, if it is not present in the map already. factory, P1 param1, P2 param2) It puts an object into the map based on the key.
public void	readExternal(ObjectInput in) Implements java.io.Externalizable.readExternal. The object implements the readExternal method to restore its contents by calling the methods of DataInput for primitive types and readObject for objects, strings and arrays.
public boolean	remove(Object key, Object value) Overrides default java.util.Map.remove. Implements java.util.concurrent.ConcurrentMap.remove. Removes the entry for a key only if currently mapped to a given value.
public V	remove(Object key) Implements java.util.Map.remove. Removes the mapping for a key from this map if it is present (optional operation).
public V	removeKey(K key) Implements org.eclipse.collections.api.map.MutableMapIterable.removeKey. Remove an entry from the map at the specified `key`.
public boolean	replace(K key, V oldValue, V newValue) Overrides default java.util.Map.replace. Implements java.util.concurrent.ConcurrentMap.replace. Replaces the entry for a key only if currently mapped to a given value.
public V	replace(K key, V value) Overrides default java.util.Map.replace. Implements java.util.concurrent.ConcurrentMap.replace. Replaces the entry for a key only if currently mapped to some value.
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)
public int	size() Implements org.eclipse.collections.api.RichIterable.size, java.util.Map.size. Returns the number of key-value mappings in this map.
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 boolean	slowReplace(K key, V oldValue, V newValue, int hash, Object[] currentArray)
private V	slowReplace(K key, V value, 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)
public ConcurrentMutableMap<K, V>	tap(Procedure<? super V> procedure) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMap.tap. Implements org.eclipse.collections.api.map.ConcurrentMutableMap.tap, org.eclipse.collections.api.map.MutableMap.tap, org.eclipse.collections.api.map.MutableMapIterable.tap, org.eclipse.collections.api.map.MapIterable.tap, org.eclipse.collections.api.RichIterable.tap. Executes the Procedure for each value of the map and returns `this`.
public ImmutableMap<K, V>	toImmutable() Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMap.toImmutable. Implements org.eclipse.collections.api.map.MutableMapIterable.toImmutable, org.eclipse.collections.api.map.UnsortedMapIterable.toImmutable, org.eclipse.collections.api.map.MapIterable.toImmutable. Returns an immutable copy of this map.
public String	toString() Overrides org.eclipse.collections.impl.AbstractRichIterable.toString. Implements org.eclipse.collections.api.map.MapIterable.toString, org.eclipse.collections.api.RichIterable.toString. Returns a string with the keys and values of this map separated by commas with spaces and enclosed in curly braces.
private void	transfer(Object[] src, ConcurrentHashMapUnsafe.ResizeContainer resizeContainer)
private void	unconditionalCopy(Object[] dest, ConcurrentHashMapUnsafe.Entry<K, V> toCopyEntry)
public V	updateValue(K key, Function0<? extends V> factory, Function<? super V, ? extends V> function) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable.updateValue. Implements org.eclipse.collections.api.map.MutableMapIterable.updateValue. Looks up the value associated with `key`, applies the `function` to it, and replaces the value.
public <P> V	updateValueWith(K key, Function0<? extends V> factory, Function2<? super V, ? super P, ? extends V> function, P parameter) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable.updateValueWith. Implements org.eclipse.collections.api.map.MutableMapIterable.updateValueWith. Same as `updateValue(Object, Function0, Function)` with a Function2 and specified parameter which is passed to the function.
public Collection<V>	values() Implements java.util.Map.values. Returns a `Collection` view of the values contained in this map.
public ConcurrentHashMapUnsafe<K, V>	withAllKeyValueArguments(Pair<? extends K, ? extends V>... keyValues) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMap.withAllKeyValueArguments. Implements org.eclipse.collections.api.map.MutableMap.withAllKeyValueArguments, org.eclipse.collections.api.map.MutableMapIterable.withAllKeyValueArguments. Convenience var-args version of withAllKeyValues
public ConcurrentHashMapUnsafe<K, V>	withAllKeyValues(Iterable<? extends Pair<? extends K, ? extends V>> keyValues) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMap.withAllKeyValues. Implements org.eclipse.collections.api.map.MutableMap.withAllKeyValues, org.eclipse.collections.api.map.MutableMapIterable.withAllKeyValues. This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing elements.
public ConcurrentHashMapUnsafe<K, V>	withKeyValue(K key, V value) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMap.withKeyValue. Implements org.eclipse.collections.api.map.MutableMap.withKeyValue, org.eclipse.collections.api.map.MutableMapIterable.withKeyValue. This method allows mutable, fixed size, and immutable maps the ability to add elements to their existing elements.
public ConcurrentHashMapUnsafe<K, V>	withoutAllKeys(Iterable<? extends K> keys) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMap.withoutAllKeys. Implements org.eclipse.collections.api.map.MutableMap.withoutAllKeys, org.eclipse.collections.api.map.MutableMapIterable.withoutAllKeys. This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing elements.
public ConcurrentHashMapUnsafe<K, V>	withoutKey(K key) Overrides org.eclipse.collections.impl.map.mutable.AbstractMutableMap.withoutKey. Implements org.eclipse.collections.api.map.MutableMap.withoutKey, org.eclipse.collections.api.map.MutableMapIterable.withoutKey. This method allows mutable, fixed size, and immutable maps the ability to remove elements from their existing elements.
public void	writeExternal(ObjectOutput out) Implements java.io.Externalizable.writeExternal. The object implements the writeExternal method to save its contents by calling the methods of DataOutput for its primitive values or calling the writeObject method of ObjectOutput for objects, strings, and arrays.

public Class ConcurrentHashMapUnsafe<K, V>

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary