com.gs.collections.impl.map.mutable

Class ConcurrentHashMapUnsafe<K,V>

java.lang.Object

com.gs.collections.impl.map.AbstractMapIterable<K,V>

com.gs.collections.impl.map.mutable.AbstractMutableMap<K,V>

com.gs.collections.impl.map.mutable.ConcurrentHashMapUnsafe<K,V>

All Implemented Interfaces:

com.gs.collections.api.InternalIterable<V>, com.gs.collections.api.map.ConcurrentMutableMap<K,V>, com.gs.collections.api.map.MapIterable<K,V>, com.gs.collections.api.map.MutableMap<K,V>, com.gs.collections.api.map.UnsortedMapIterable<K,V>, com.gs.collections.api.RichIterable<V>, java.io.Externalizable, java.io.Serializable, java.lang.Cloneable, java.lang.Iterable<V>, java.util.concurrent.ConcurrentMap<K,V>, java.util.Map<K,V>

public class ConcurrentHashMapUnsafe<K,V>
extends AbstractMutableMap<K,V>
implements com.gs.collections.api.map.ConcurrentMutableMap<K,V>, java.io.Externalizable

See Also:

Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class com.gs.collections.impl.map.mutable.AbstractMutableMap

AbstractMutableMap.ValuesCollectionCommon<V>

Constructor Summary

Constructors

Constructor and Description
ConcurrentHashMapUnsafe()
ConcurrentHashMapUnsafe(int initialCapacity)

Method Summary

Methods

Modifier and Type	Method and Description
void	clear()
com.gs.collections.api.map.MutableMap<K,V>	clone() Returns a string representation of this map.
<E> com.gs.collections.api.map.MutableMap<K,V>	collectKeysAndValues(java.lang.Iterable<E> iterable, com.gs.collections.api.block.function.Function<? super E,? extends K> keyFunction, com.gs.collections.api.block.function.Function<? super E,? extends V> valueFunction) Adds all the entries derived from collection to this.
boolean	containsKey(java.lang.Object key)
boolean	containsValue(java.lang.Object value)
int	countEntries()
java.util.Set<java.util.Map.Entry<K,V>>	entrySet()
boolean	equals(java.lang.Object o) Follows the same general contract as Map.equals(Object).
void	forEach(com.gs.collections.api.block.procedure.Procedure<? super V> procedure) The procedure is executed for each element in the iterable.
void	forEachKey(com.gs.collections.api.block.procedure.Procedure<? super K> procedure) Calls the procedure with each key of the map.
void	forEachKeyValue(com.gs.collections.api.block.procedure.Procedure2<? super K,? super V> procedure) Calls the procedure with each key-value pair of the map.
void	forEachValue(com.gs.collections.api.block.procedure.Procedure<? super V> procedure) Calls the procedure with each value of the map.
<P> void	forEachWith(com.gs.collections.api.block.procedure.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(com.gs.collections.api.block.procedure.primitive.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(java.lang.Object key)
V	getIfAbsent(K key, com.gs.collections.api.block.function.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, com.gs.collections.api.block.function.Function<? super K,? extends V> factory)
V	getIfAbsentPut(K key, com.gs.collections.api.block.function.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, com.gs.collections.api.block.function.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, com.gs.collections.api.block.function.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, com.gs.collections.api.block.function.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.
java.util.Iterator<V>	iterator()
java.util.Set<K>	keySet()
com.gs.collections.api.map.MutableMap<K,V>	newEmpty() Creates a new instance of the same type, using the default capacity and growth parameters.
<K,V> com.gs.collections.api.map.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(java.util.Map<NK,NV> map)
boolean	notEmpty() The English equivalent of !this.isEmpty()
void	parallelForEachKeyValue(java.util.List<com.gs.collections.api.block.procedure.Procedure2<K,V>> blocks, java.util.concurrent.Executor executor)
void	parallelForEachValue(java.util.List<com.gs.collections.api.block.procedure.Procedure<V>> blocks, java.util.concurrent.Executor executor)
V	put(K key, V value)
void	putAll(java.util.Map<? extends K,? extends V> map)
void	putAllInParallel(java.util.Map<K,V> map, int chunks, java.util.concurrent.Executor executor)
V	putIfAbsent(K key, V value)
<P1,P2> V	putIfAbsentGetIfPresent(K key, com.gs.collections.api.block.function.Function2<K,V,K> keyTransformer, com.gs.collections.api.block.function.Function3<P1,P2,K,V> factory, P1 param1, P2 param2) It puts an object into the map based on the key.
void	readExternal(java.io.ObjectInput in)
V	remove(java.lang.Object key)
boolean	remove(java.lang.Object key, java.lang.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.
com.gs.collections.api.map.ImmutableMap<K,V>	toImmutable() Returns an immutable copy of this map.
java.lang.String	toString() Returns a string representation of this MapIterable.
V	updateValue(K key, com.gs.collections.api.block.function.Function0<? extends V> factory, com.gs.collections.api.block.function.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, com.gs.collections.api.block.function.Function0<? extends V> factory, com.gs.collections.api.block.function.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.
java.util.Collection<V>	values()
ConcurrentHashMapUnsafe<K,V>	withAllKeyValueArguments(com.gs.collections.api.tuple.Pair<? extends K,? extends V>... keyValues) Convenience var-args version of withAllKeyValues
ConcurrentHashMapUnsafe<K,V>	withAllKeyValues(java.lang.Iterable<? extends com.gs.collections.api.tuple.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(java.lang.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(java.io.ObjectOutput out)

Methods inherited from class com.gs.collections.impl.map.mutable.AbstractMutableMap

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, zipWithIndex

Methods inherited from class com.gs.collections.impl.map.AbstractMapIterable

allSatisfy, 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, isAbsent, keyAndValueEquals, keyAndValueHashCode, 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, zipWithIndex

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.gs.collections.api.map.MutableMap

add, 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, zipWithIndex

Methods inherited from interface com.gs.collections.api.map.MapIterable

detect, getIfAbsentValue, keysView, keyValuesView, valuesView

Methods inherited from interface com.gs.collections.api.RichIterable

allSatisfy, 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, zipWithIndex

Constructor Detail

ConcurrentHashMapUnsafe

public ConcurrentHashMapUnsafe()

ConcurrentHashMapUnsafe

public ConcurrentHashMapUnsafe(int initialCapacity)

Method Detail

newMap

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

newMap

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

putIfAbsent

public V putIfAbsent(K key,
            V value)

Specified by:

putIfAbsent in interface java.util.concurrent.ConcurrentMap<K,V>

countEntries

public int countEntries()

getIfAbsentPut

public V getIfAbsentPut(K key,
               com.gs.collections.api.block.function.Function<? super K,? extends V> factory)

getIfAbsentPut

public V getIfAbsentPut(K key,
               com.gs.collections.api.block.function.Function0<? extends V> factory)

Description copied from interface: com.gs.collections.api.map.MutableMap

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 com.gs.collections.api.map.MutableMap<K,V>

Overrides:

getIfAbsentPut in class AbstractMutableMap<K,V>

getIfAbsentPut

public V getIfAbsentPut(K key,
               V value)

Description copied from interface: com.gs.collections.api.map.MutableMap

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 com.gs.collections.api.map.MutableMap<K,V>

Overrides:

getIfAbsentPut in class AbstractMutableMap<K,V>

putIfAbsentGetIfPresent

public <P1,P2> V putIfAbsentGetIfPresent(K key,
                                com.gs.collections.api.block.function.Function2<K,V,K> keyTransformer,
                                com.gs.collections.api.block.function.Function3<P1,P2,K,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(java.lang.Object key,
             java.lang.Object value)

Specified by:

remove in interface java.util.concurrent.ConcurrentMap<K,V>

size

public int size()

Description copied from interface: com.gs.collections.api.RichIterable

Returns the number of items in this iterable.

Specified by:

size in interface com.gs.collections.api.RichIterable<V>

Specified by:

size in interface java.util.Map<K,V>

isEmpty

public boolean isEmpty()

Description copied from interface: com.gs.collections.api.RichIterable

Returns true if this iterable has zero items.

Specified by:

isEmpty in interface com.gs.collections.api.RichIterable<V>

Specified by:

isEmpty in interface java.util.Map<K,V>

Overrides:

isEmpty in class AbstractMapIterable<K,V>

containsKey

public boolean containsKey(java.lang.Object key)

Specified by:

containsKey in interface com.gs.collections.api.map.MapIterable<K,V>

Specified by:

containsKey in interface java.util.Map<K,V>

See Also:

Map.containsKey(Object)

containsValue

public boolean containsValue(java.lang.Object value)

Specified by:

containsValue in interface com.gs.collections.api.map.MapIterable<K,V>

Specified by:

containsValue in interface java.util.Map<K,V>

See Also:

Map.containsValue(Object)

get

public V get(java.lang.Object key)

Specified by:

get in interface com.gs.collections.api.map.MapIterable<K,V>

Specified by:

get in interface java.util.Map<K,V>

See Also:

Map.get(Object)

put

public V put(K key,
    V value)

Specified by:

put in interface java.util.Map<K,V>

putAllInParallel

public void putAllInParallel(java.util.Map<K,V> map,
                    int chunks,
                    java.util.concurrent.Executor executor)

putAll

public void putAll(java.util.Map<? extends K,? extends V> map)

Specified by:

putAll in interface java.util.Map<K,V>

clear

public void clear()

Specified by:

clear in interface java.util.Map<K,V>

keySet

public java.util.Set<K> keySet()

Specified by:

keySet in interface java.util.Map<K,V>

values

public java.util.Collection<V> values()

Specified by:

values in interface java.util.Map<K,V>

entrySet

public java.util.Set<java.util.Map.Entry<K,V>> entrySet()

Specified by:

entrySet in interface java.util.Map<K,V>

replace

public boolean replace(K key,
              V oldValue,
              V newValue)

Specified by:

replace in interface java.util.concurrent.ConcurrentMap<K,V>

replace

public V replace(K key,
        V value)

Specified by:

replace in interface java.util.concurrent.ConcurrentMap<K,V>

remove

public V remove(java.lang.Object key)

Specified by:

remove in interface java.util.Map<K,V>

parallelForEachKeyValue

public void parallelForEachKeyValue(java.util.List<com.gs.collections.api.block.procedure.Procedure2<K,V>> blocks,
                           java.util.concurrent.Executor executor)

parallelForEachValue

public void parallelForEachValue(java.util.List<com.gs.collections.api.block.procedure.Procedure<V>> blocks,
                        java.util.concurrent.Executor executor)

hashCode

public int hashCode()

Description copied from interface: com.gs.collections.api.map.MapIterable

Follows the same general contract as Map.hashCode().

Specified by:

hashCode in interface com.gs.collections.api.map.MapIterable<K,V>

Specified by:

hashCode in interface java.util.Map<K,V>

Overrides:

hashCode in class java.lang.Object

equals

public boolean equals(java.lang.Object o)

Description copied from interface: com.gs.collections.api.map.MapIterable

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

Specified by:

equals in interface com.gs.collections.api.map.MapIterable<K,V>

Specified by:

equals in interface java.util.Map<K,V>

Overrides:

equals in class java.lang.Object

toString

public java.lang.String toString()

Description copied from interface: com.gs.collections.api.map.MapIterable

Returns a string representation of this MapIterable. The string representation consists of a list of the map's key-value pairs in the order they are returned by its iterator. The key and value in each key-value pair are separated by a colon (":") and each pair is enclosed in square brackets ("[]"). Adjacent key-value pairs are separated by the characters ", " (comma and space). Keys and values are converted to strings as by String.valueOf(Object).

Specified by:

toString in interface com.gs.collections.api.map.MapIterable<K,V>

Specified by:

toString in interface com.gs.collections.api.RichIterable<V>

Overrides:

toString in class java.lang.Object

Returns:

a string representation of this MapIterable

readExternal

public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException

Specified by:

readExternal in interface java.io.Externalizable

Throws:

java.io.IOException

java.lang.ClassNotFoundException

writeExternal

public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException

Specified by:

writeExternal in interface java.io.Externalizable

Throws:

java.io.IOException

newMap

public static <NK,NV> ConcurrentHashMapUnsafe<NK,NV> newMap(java.util.Map<NK,NV> map)

withKeyValue

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

Description copied from interface: com.gs.collections.api.map.MutableMap

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 com.gs.collections.api.map.MutableMap<K,V>

Overrides:

withKeyValue in class AbstractMutableMap<K,V>

See Also:

Map.put(Object, Object)

withAllKeyValues

public ConcurrentHashMapUnsafe<K,V> withAllKeyValues(java.lang.Iterable<? extends com.gs.collections.api.tuple.Pair<? extends K,? extends V>> keyValues)

Description copied from interface: com.gs.collections.api.map.MutableMap

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 of 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 com.gs.collections.api.map.MutableMap<K,V>

Overrides:

withAllKeyValues in class AbstractMutableMap<K,V>

See Also:

Map.put(Object, Object)

withAllKeyValueArguments

public ConcurrentHashMapUnsafe<K,V> withAllKeyValueArguments(com.gs.collections.api.tuple.Pair<? extends K,? extends V>... keyValues)

Description copied from interface: com.gs.collections.api.map.MutableMap

Convenience var-args version of withAllKeyValues

Specified by:

withAllKeyValueArguments in interface com.gs.collections.api.map.MutableMap<K,V>

Overrides:

withAllKeyValueArguments in class AbstractMutableMap<K,V>

See Also:

MutableMap.withAllKeyValues(Iterable)

withoutKey

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

Description copied from interface: com.gs.collections.api.map.MutableMap

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 com.gs.collections.api.map.MutableMap<K,V>

Overrides:

withoutKey in class AbstractMutableMap<K,V>

See Also:

Map.remove(Object)

withoutAllKeys

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

Description copied from interface: com.gs.collections.api.map.MutableMap

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 of 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 com.gs.collections.api.map.MutableMap<K,V>

Overrides:

withoutAllKeys in class AbstractMutableMap<K,V>

See Also:

Map.remove(Object)

clone

public com.gs.collections.api.map.MutableMap<K,V> clone()

Description copied from class: AbstractMutableMap

Returns a string representation of this map. The string representation consists of a list of key-value mappings in the order returned by the map's entrySet view's iterator, enclosed in braces ("{}"). Adjacent mappings are separated by the characters ", " (comma and space). Each key-value mapping is rendered as the key followed by an equals sign ("=") followed by the associated value. Keys and values are converted to strings as by String.valueOf(Object).

This 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.

Specified by:

clone in interface com.gs.collections.api.map.MutableMap<K,V>

Specified by:

clone in class AbstractMutableMap<K,V>

Returns:

a String representation of this map.

newEmpty

public <K,V> com.gs.collections.api.map.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: com.gs.collections.api.RichIterable

The English equivalent of !this.isEmpty()

Specified by:

notEmpty in interface com.gs.collections.api.RichIterable<V>

Overrides:

notEmpty in class AbstractMapIterable<K,V>

forEach

public void forEach(com.gs.collections.api.block.procedure.Procedure<? super V> procedure)

Description copied from interface: com.gs.collections.api.InternalIterable

The procedure is executed for each element in the iterable.

e.g.
 people.forEach(new Procedure()
 {
     public void value(Person person)
     {
         LOGGER.info(person.getName());
     }
 });
 

Specified by:

forEach in interface com.gs.collections.api.InternalIterable<V>

Overrides:

forEach in class AbstractMapIterable<K,V>

forEachWithIndex

public void forEachWithIndex(com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure<? super V> objectIntProcedure)

Description copied from interface: com.gs.collections.api.InternalIterable

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

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

Specified by:

forEachWithIndex in interface com.gs.collections.api.InternalIterable<V>

Overrides:

forEachWithIndex in class AbstractMapIterable<K,V>

iterator

public java.util.Iterator<V> iterator()

Specified by:

iterator in interface java.lang.Iterable<V>

Overrides:

iterator in class AbstractMutableMap<K,V>

newEmpty

public com.gs.collections.api.map.MutableMap<K,V> newEmpty()

Description copied from interface: com.gs.collections.api.map.MutableMap

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

Specified by:

newEmpty in interface com.gs.collections.api.map.MutableMap<K,V>

forEachValue

public void forEachValue(com.gs.collections.api.block.procedure.Procedure<? super V> procedure)

Description copied from interface: com.gs.collections.api.map.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 com.gs.collections.api.map.MapIterable<K,V>

Overrides:

forEachValue in class AbstractMapIterable<K,V>

forEachKey

public void forEachKey(com.gs.collections.api.block.procedure.Procedure<? super K> procedure)

Description copied from interface: com.gs.collections.api.map.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 com.gs.collections.api.map.MapIterable<K,V>

Overrides:

forEachKey in class AbstractMapIterable<K,V>

forEachKeyValue

public void forEachKeyValue(com.gs.collections.api.block.procedure.Procedure2<? super K,? super V> procedure)

Description copied from interface: com.gs.collections.api.map.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(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");
 

Specified by:

forEachKeyValue in interface com.gs.collections.api.map.MapIterable<K,V>

collectKeysAndValues

public <E> com.gs.collections.api.map.MutableMap<K,V> collectKeysAndValues(java.lang.Iterable<E> iterable,
                                                                  com.gs.collections.api.block.function.Function<? super E,? extends K> keyFunction,
                                                                  com.gs.collections.api.block.function.Function<? super E,? extends V> valueFunction)

Description copied from interface: com.gs.collections.api.map.MutableMap

Adds all the entries derived from collection 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.

Specified by:

collectKeysAndValues in interface com.gs.collections.api.map.MutableMap<K,V>

removeKey

public V removeKey(K key)

Description copied from interface: com.gs.collections.api.map.MutableMap

Remove an entry from the map at the specified key.

Specified by:

removeKey in interface com.gs.collections.api.map.MutableMap<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,
                       com.gs.collections.api.block.function.Function<? super P,? extends V> function,
                       P parameter)

Description copied from interface: com.gs.collections.api.map.MutableMap

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 com.gs.collections.api.map.MutableMap<K,V>

Overrides:

getIfAbsentPutWith in class AbstractMutableMap<K,V>

getIfAbsent

public V getIfAbsent(K key,
            com.gs.collections.api.block.function.Function0<? extends V> function)

Description copied from interface: com.gs.collections.api.map.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 com.gs.collections.api.map.MapIterable<K,V>

Overrides:

getIfAbsent in class AbstractMapIterable<K,V>

getIfAbsentWith

public <P> V getIfAbsentWith(K key,
                    com.gs.collections.api.block.function.Function<? super P,? extends V> function,
                    P parameter)

Description copied from interface: com.gs.collections.api.map.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 com.gs.collections.api.map.MapIterable<K,V>

Overrides:

getIfAbsentWith in class AbstractMapIterable<K,V>

ifPresentApply

public <A> A ifPresentApply(K key,
                   com.gs.collections.api.block.function.Function<? super V,? extends A> function)

Description copied from interface: com.gs.collections.api.map.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 com.gs.collections.api.map.MapIterable<K,V>

Overrides:

ifPresentApply in class AbstractMapIterable<K,V>

forEachWith

public <P> void forEachWith(com.gs.collections.api.block.procedure.Procedure2<? super V,? super P> procedure,
                   P parameter)

Description copied from interface: com.gs.collections.api.InternalIterable

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

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

Specified by:

forEachWith in interface com.gs.collections.api.InternalIterable<V>

Overrides:

forEachWith in class AbstractMapIterable<K,V>

updateValue

public V updateValue(K key,
            com.gs.collections.api.block.function.Function0<? extends V> factory,
            com.gs.collections.api.block.function.Function<? super V,? extends V> function)

Description copied from interface: com.gs.collections.api.map.MutableMap

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 com.gs.collections.api.map.MutableMap<K,V>

Overrides:

updateValue in class AbstractMutableMap<K,V>

updateValueWith

public <P> V updateValueWith(K key,
                    com.gs.collections.api.block.function.Function0<? extends V> factory,
                    com.gs.collections.api.block.function.Function2<? super V,? super P,? extends V> function,
                    P parameter)

Description copied from interface: com.gs.collections.api.map.MutableMap

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

Specified by:

updateValueWith in interface com.gs.collections.api.map.MutableMap<K,V>

Overrides:

updateValueWith in class AbstractMutableMap<K,V>

toImmutable

public com.gs.collections.api.map.ImmutableMap<K,V> toImmutable()

Description copied from interface: com.gs.collections.api.map.MutableMap

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

The returned map will be Serializable if this map is Serializable.

Specified by:

toImmutable in interface com.gs.collections.api.map.MutableMap<K,V>

Specified by:

toImmutable in interface com.gs.collections.api.map.UnsortedMapIterable<K,V>

Overrides:

toImmutable in class AbstractMutableMap<K,V>