UnifiedMap (GS Collections

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.UnifiedMap<K,V>

All Implemented Interfaces:

InternalIterable<V>, MapIterable<K,V>, MutableMap<K,V>, UnsortedMapIterable<K,V>, RichIterable<V>, BatchIterable<V>, Externalizable, Serializable, Cloneable, Iterable<V>, Map<K,V>
```
@NotThreadSafe
public class UnifiedMap<K,V>
extends AbstractMutableMap<K,V>
implements Externalizable, BatchIterable<V>
```
UnifiedMap stores key/value pairs in a single array, where alternate slots are keys and values. This is nicer to CPU caches as consecutive memory addresses are very cheap to access. Entry objects are not stored in the table like in java.util.HashMap. Instead of trying to deal with collisions in the main array using Entry objects, we put a special object in the key slot and put a regular Object[] in the value slot. The array contains the key value pairs in consecutive slots, just like the main array, but it's a linear list with no hashing.
The final result is a Map implementation that's leaner than java.util.HashMap and faster than Trove's THashMap. The best of both approaches unified together, and thus the name UnifiedMap.

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Constructor Summary

Constructors
Constructor and Description
`UnifiedMap()`
`UnifiedMap(int initialCapacity)`
`UnifiedMap(int initialCapacity, float loadFactor)`
`UnifiedMap(Map<? extends K,? extends V> map)`
`UnifiedMap(Pair<K,V>... pairs)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`batchForEach(Procedure<? super V> procedure, int sectionIndex, int sectionCount)`
`void`	`clear()`
`UnifiedMap<K,V>`	`clone()` Returns a string representation of this map.
`<E> MutableMap<K,V>`	`collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)` Adds all the entries derived from `collection` to `this`.
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Set<Map.Entry<K,V>>`	`entrySet()`
`boolean`	`equals(Object object)` 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)`
`int`	`getBatchCount(int batchSize)`
`int`	`getCollidingBuckets()`
`V`	`getIfAbsentPut(K key, Function0<? extends V> function)` 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.
`int`	`getMapMemoryUsedInWords()` Returns the number of JVM words that is used by this map.
`int`	`hashCode()` Follows the same general contract as `Map.hashCode()`.
`boolean`	`isEmpty()` Returns true if this iterable has zero items.
`Set<K>`	`keySet()`
`MutableMap<K,V>`	`newEmpty()` Creates a new instance of the same type, using the default capacity and growth parameters.
`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> UnifiedMap<K,V>`	`newMap()`
`static <K,V> UnifiedMap<K,V>`	`newMap(int size)`
`static <K,V> UnifiedMap<K,V>`	`newMap(int size, float loadFactor)`
`static <K,V> UnifiedMap<K,V>`	`newMap(Map<? extends K,? extends V> map)`
`static <K,V> UnifiedMap<K,V>`	`newMapWith(Pair<K,V>... pairs)`
`static <K,V> UnifiedMap<K,V>`	`newWithKeysValues(K key, V value)`
`static <K,V> UnifiedMap<K,V>`	`newWithKeysValues(K key1, V value1, K key2, V value2)`
`static <K,V> UnifiedMap<K,V>`	`newWithKeysValues(K key1, V value1, K key2, V value2, K key3, V value3)`
`static <K,V> UnifiedMap<K,V>`	`newWithKeysValues(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)`
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> map)`
`void`	`readExternal(ObjectInput in)`
`V`	`remove(Object key)`
`V`	`removeKey(K key)` Remove an entry from the map at the specified `key`.
`int`	`size()` Returns the number of items in this iterable.
`ImmutableMap<K,V>`	`toImmutable()` Returns an immutable copy of this map.
`String`	`toString()` Returns a string representation of this MapIterable.
`V`	`updateValue(K key, Function0<? extends V> factory, Function<? super V,? extends V> function)` Looks up the value associated with `key`, applies the `function` to it, and replaces the value.
`<P> V`	`updateValueWith(K key, Function0<? extends V> factory, Function2<? super V,? super P,? extends V> function, P parameter)` Same as `MutableMap.updateValue(Object, Function0, Function)` with a Function2 and specified parameter which is passed to the function.
`Collection<V>`	`values()`
`UnifiedMap<K,V>`	`withKeysValues(K key, V value)`
`UnifiedMap<K,V>`	`withKeysValues(K key1, V value1, K key2, V value2)`
`UnifiedMap<K,V>`	`withKeysValues(K key1, V value1, K key2, V value2, K key3, V value3)`
`UnifiedMap<K,V>`	`withKeysValues(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)`
`void`	`writeExternal(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, iterator, keysView, keyValuesView, partition, partitionWith, reject, reject, select, select, selectInstancesOf, selectWith, valuesView, withAllKeyValueArguments, withAllKeyValues, withKeyValue, withoutAllKeys, withoutKey, 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, forEach, getFirst, getIfAbsent, getIfAbsentValue, getIfAbsentWith, getLast, groupBy, groupByEach, ifPresentApply, injectInto, injectInto, injectInto, injectInto, injectInto, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, 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
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.gs.collections.impl.parallel.BatchIterable
forEach

Methods inherited from interface com.gs.collections.api.map.MapIterable
getIfAbsent, getIfAbsentValue, getIfAbsentWith, ifPresentApply

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, 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, notEmpty, 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 interface com.gs.collections.api.InternalIterable
forEach

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll

- Constructor Detail
  - UnifiedMap
```
public UnifiedMap()
```
  - UnifiedMap
```
public UnifiedMap(int initialCapacity)
```
  - UnifiedMap
```
public UnifiedMap(int initialCapacity,
                  float loadFactor)
```
  - UnifiedMap
```
public UnifiedMap(Map<? extends K,? extends V> map)
```
  - UnifiedMap
```
public UnifiedMap(Pair<K,V>... pairs)
```
- Method Detail
  - newMap
```
public static <K,V> UnifiedMap<K,V> newMap()
```
  - newMap
```
public static <K,V> UnifiedMap<K,V> newMap(int size)
```
  - newMap
```
public static <K,V> UnifiedMap<K,V> newMap(int size,
                                           float loadFactor)
```
  - newMap
```
public static <K,V> UnifiedMap<K,V> newMap(Map<? extends K,? extends V> map)
```
  - newMapWith
```
public static <K,V> UnifiedMap<K,V> newMapWith(Pair<K,V>... pairs)
```
  - newWithKeysValues
```
public static <K,V> UnifiedMap<K,V> newWithKeysValues(K key,
                                                      V value)
```
  - newWithKeysValues
```
public static <K,V> UnifiedMap<K,V> newWithKeysValues(K key1,
                                                      V value1,
                                                      K key2,
                                                      V value2)
```
  - newWithKeysValues
```
public static <K,V> UnifiedMap<K,V> newWithKeysValues(K key1,
                                                      V value1,
                                                      K key2,
                                                      V value2,
                                                      K key3,
                                                      V value3)
```
  - newWithKeysValues
```
public static <K,V> UnifiedMap<K,V> newWithKeysValues(K key1,
                                                      V value1,
                                                      K key2,
                                                      V value2,
                                                      K key3,
                                                      V value3,
                                                      K key4,
                                                      V value4)
```
  - withKeysValues
```
public UnifiedMap<K,V> withKeysValues(K key,
                                      V value)
```
  - withKeysValues
```
public UnifiedMap<K,V> withKeysValues(K key1,
                                      V value1,
                                      K key2,
                                      V value2)
```
  - withKeysValues
```
public UnifiedMap<K,V> withKeysValues(K key1,
                                      V value1,
                                      K key2,
                                      V value2,
                                      K key3,
                                      V value3)
```
  - withKeysValues
```
public UnifiedMap<K,V> withKeysValues(K key1,
                                      V value1,
                                      K key2,
                                      V value2,
                                      K key3,
                                      V value3,
                                      K key4,
                                      V value4)
```
  - clone
```
public UnifiedMap<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 MutableMap<K,V>
    
    Specified by:
    
    clone in class AbstractMutableMap<K,V>
    
    Returns:
    
    a String representation of this map.
  - newEmpty
```
public MutableMap<K,V> newEmpty()
```
    Description copied from interface: MutableMap
    
    Creates a new instance of the same type, using the default capacity and growth parameters.
    
    Specified by:
    
    newEmpty in interface MutableMap<K,V>
  - newEmpty
```
public 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>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
  - updateValue
```
public V updateValue(K key,
                     Function0<? extends V> factory,
                     Function<? super V,? extends V> function)
```
    Description copied from interface: 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 MutableMap<K,V>
    
    Overrides:
    
    updateValue in class AbstractMutableMap<K,V>
  - 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: 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 MutableMap<K,V>
    
    Overrides:
    
    updateValueWith in class AbstractMutableMap<K,V>
  - getIfAbsentPut
```
public V getIfAbsentPut(K key,
                        Function0<? extends V> function)
```
    Description copied from interface: 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 MutableMap<K,V>
    
    Overrides:
    
    getIfAbsentPut in class AbstractMutableMap<K,V>
  - getIfAbsentPut
```
public V getIfAbsentPut(K key,
                        V value)
```
    Description copied from interface: 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 MutableMap<K,V>
    
    Overrides:
    
    getIfAbsentPut in class AbstractMutableMap<K,V>
  - getIfAbsentPutWith
```
public <P> V getIfAbsentPutWith(K key,
                                Function<? super P,? extends V> function,
                                P parameter)
```
    Description copied from interface: 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 MutableMap<K,V>
    
    Overrides:
    
    getIfAbsentPutWith in class AbstractMutableMap<K,V>
  - getCollidingBuckets
```
public int getCollidingBuckets()
```
  - getMapMemoryUsedInWords
```
public int getMapMemoryUsedInWords()
```
    Returns the number of JVM words that is used by this map. A word is 4 bytes in a 32bit VM and 8 bytes in a 64bit VM. Each array has a 2 word header, thus the formula is: words = (internal table length + 2) + sum (for all chains (chain length + 2))
    
    Returns:
    
    the number of JVM words that is used by this map.
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface MapIterable<K,V>
    
    Specified by:
    
    get in interface Map<K,V>
    
    See Also:
    
    Map.get(Object)
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface MapIterable<K,V>
    
    Specified by:
    
    containsKey in interface Map<K,V>
    
    See Also:
    
    Map.containsKey(Object)
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface MapIterable<K,V>
    
    Specified by:
    
    containsValue in interface Map<K,V>
    
    See Also:
    
    Map.containsValue(Object)
  - 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(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 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 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 MutableMap<K,V>
  - removeKey
```
public V removeKey(K key)
```
    Description copied from interface: MutableMap
    
    Remove an entry from the map at the specified key.
    
    Specified by:
    
    removeKey in interface MutableMap<K,V>
    
    Returns:
    
    The value removed from entry at key, or null if not found.
    
    See Also:
    
    Map.remove(Object)
  - getBatchCount
```
public int getBatchCount(int batchSize)
```
    Specified by:
    
    getBatchCount in interface BatchIterable<V>
  - batchForEach
```
public void batchForEach(Procedure<? super V> procedure,
                         int sectionIndex,
                         int sectionCount)
```
    Specified by:
    
    batchForEach in interface BatchIterable<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>
  - 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>
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: RichIterable
    
    Returns true if this iterable has zero items.
    
    Specified by:
    
    isEmpty in interface RichIterable<V>
    
    Specified by:
    
    isEmpty in interface Map<K,V>
    
    Overrides:
    
    isEmpty in class AbstractMapIterable<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
  - size
```
public int size()
```
    Description copied from interface: RichIterable
    
    Returns the number of items in this iterable.
    
    Specified by:
    
    size in interface RichIterable<V>
    
    Specified by:
    
    size in interface BatchIterable<V>
    
    Specified by:
    
    size in interface Map<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet 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>
  - equals
```
public boolean equals(Object object)
```
    Description copied from interface: MapIterable
    
    Follows the same general contract as Map.equals(Object).
    
    Specified by:
    
    equals in interface MapIterable<K,V>
    
    Specified by:
    
    equals in interface Map<K,V>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Description copied from interface: MapIterable
    
    Follows the same general contract as Map.hashCode().
    
    Specified by:
    
    hashCode in interface MapIterable<K,V>
    
    Specified by:
    
    hashCode in interface Map<K,V>
    
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Description copied from interface: 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 MapIterable<K,V>
    
    Specified by:
    
    toString in interface RichIterable<V>
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a string representation of this MapIterable
  - 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
  - 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
```
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 InternalIterable<V>
    
    Overrides:
    
    forEachWithIndex 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.
```
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 InternalIterable<V>
    
    Overrides:
    
    forEachWith in class AbstractMapIterable<K,V>
  - toImmutable
```
public ImmutableMap<K,V> toImmutable()
```
    Description copied from interface: 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 MutableMap<K,V>
    
    Specified by:
    
    toImmutable in interface UnsortedMapIterable<K,V>
    
    Overrides:
    
    toImmutable in class AbstractMutableMap<K,V>

Class UnifiedMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Methods inherited from interface com.gs.collections.impl.parallel.BatchIterable

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

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

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.Map

Constructor Detail

UnifiedMap

UnifiedMap

UnifiedMap

UnifiedMap

UnifiedMap

Method Detail

newMap

newMap

newMap

newMap

newMapWith

newWithKeysValues

newWithKeysValues

newWithKeysValues

newWithKeysValues

withKeysValues

withKeysValues

withKeysValues

withKeysValues

clone

newEmpty

newEmpty

clear

put

updateValue

updateValueWith

getIfAbsentPut

getIfAbsentPut

getIfAbsentPutWith

getCollidingBuckets

getMapMemoryUsedInWords

get

containsKey

containsValue

forEachKeyValue

collectKeysAndValues

removeKey

getBatchCount

batchForEach

forEachKey

forEachValue

isEmpty

putAll

remove

size

entrySet

keySet

values

equals

hashCode

toString

readExternal

writeExternal

forEachWithIndex

forEachWith

toImmutable