Package org.eclipse.collections.impl.map.mutable

Class UnifiedMap<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.UnifiedMap<K,V>
All Implemented Interfaces:
Externalizable, Serializable, Cloneable, Iterable<V>, Map<K,V>, InternalIterable<V>, MapIterable<K,V>, MutableMap<K,V>, MutableMapIterable<K,V>, UnsortedMapIterable<K,V>, RichIterable<V>, BatchIterable<V>
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:

  • Constructor Details

    • 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 Details

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

    • newMapWith

      public static <K, V> UnifiedMap<K,V> newMapWith(Iterable<Pair<K,V>> inputIterable)

    • 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()
      Specified by:
      clone in interface MutableMap<K,V>
      Specified by:
      clone in class AbstractMutableMap<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>

    • 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: 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>

    • 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>

    • getIfAbsentPut

      public V getIfAbsentPut(K key, Function0<? extends V> function)
      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>

    • 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>

    • 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 Map<K,V>
      Specified by:
      get in interface MapIterable<K,V>
      See Also:

    • containsKey

      public boolean containsKey(Object key)
      Specified by:
      containsKey in interface Map<K,V>
      Specified by:
      containsKey in interface MapIterable<K,V>
      See Also:

    • containsValue

      public boolean containsValue(Object value)
      Specified by:
      containsValue in interface Map<K,V>
      Specified by:
      containsValue in interface MapIterable<K,V>
      See Also:

    • 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>

    • getFirst

      public V getFirst()
      Description copied from interface: RichIterable
      Returns the first element of an iterable. In the case of a List it is the element at the first index. In the case of any other Collection, it is the first element that would be returned during an iteration. If the iterable is empty, null is returned. If null is a valid element of the container, then a developer would need to check to see if the iterable is empty to validate that a null result was not due to the container being empty.

      The order of Sets are not guaranteed (except for TreeSets and other Ordered Set implementations), so if you use this method, the first element could be any element from the Set.

      Specified by:
      getFirst in interface RichIterable<K>
      Overrides:
      getFirst in class AbstractMapIterable<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:

    • removeIf

      public boolean removeIf(Predicate2<? super K,? super V> predicate)
      Description copied from interface: MutableMapIterable
      Remove an entry from the map if the predicate evaluates to true.
      Specified by:
      removeIf in interface MutableMapIterable<K,V>
      Returns:
      true if any entry is removed.

    • getBatchCount

      public int getBatchCount(int batchSize)
      Specified by:
      getBatchCount in interface BatchIterable<K>

    • batchForEach

      public void batchForEach(Procedure<? super V> procedure, int sectionIndex, int sectionCount)
      Specified by:
      batchForEach in interface BatchIterable<K>

    • 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 Map<K,V>
      Specified by:
      isEmpty in interface RichIterable<K>
      Overrides:
      isEmpty in class AbstractRichIterable<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 BatchIterable<K>
      Specified by:
      size in interface Map<K,V>
      Specified by:
      size in interface RichIterable<K>

    • 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 Map<K,V>
      Specified by:
      equals in interface MapIterable<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 Map<K,V>
      Specified by:
      hashCode in interface MapIterable<K,V>
      Overrides:
      hashCode 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:

    • trimToSize

      public boolean trimToSize()

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

      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>

    • 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>

    • collectValues

      public <R> MutableMap<K,R> collectValues(Function2<? super K,? super V,? extends R> function)
      Description copied from interface: MapIterable
      For each key and value of the map the function is evaluated. The results of these evaluations are returned in a new map. The map returned will use the values projected from the function rather than the original values. 
       MapIterable<City, String> collected =
     peopleByCity.collectValues((City city, Person person) -> person.getFirstName() + " " + person.getLastName());
      Specified by:
      collectValues in interface MapIterable<K,V>
      Specified by:
      collectValues in interface MutableMap<K,V>
      Specified by:
      collectValues in interface MutableMapIterable<K,V>
      Specified by:
      collectValues in interface UnsortedMapIterable<K,V>
      Overrides:
      collectValues in class AbstractMutableMap<K,V>

    • detect

      public Pair<K,V> detect(Predicate2<? super K,? super V> predicate)
      Description copied from interface: MapIterable
      Return the first key and value of the map for which the predicate evaluates to true when they are given as arguments. The predicate will only be evaluated until such pair is found or until all of the keys and values of the map have been used as arguments. That is, there may be keys and values of the map that are never used as arguments to the predicate. The result is null if predicate does not evaluate to true for any key/value combination. 
       Pair<City, Person> detected =
     peopleByCity.detect((City city, Person person) -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
      Specified by:
      detect in interface MapIterable<K,V>
      Overrides:
      detect in class AbstractMutableMapIterable<K,V>

    • detect

      public V detect(Predicate<? super V> predicate)
      Description copied from interface: RichIterable
      Returns the first element of the iterable for which the predicate evaluates to true or null in the case where no element returns true. This method is commonly called find.

      Example using a Java 8 lambda expression: 

       Person person =
     people.detect(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));

      Example using an anonymous inner class: 

       Person person =
     people.detect(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.getFirstName().equals("John") && person.getLastName().equals("Smith");
         }
     });
      Specified by:
      detect in interface RichIterable<K>
      Overrides:
      detect in class AbstractMapIterable<K,V>

    • detectWith

      public <P> V detectWith(Predicate2<? super V,? super P> predicate, P parameter)
      Description copied from interface: RichIterable
      Returns the first element that evaluates to true for the specified predicate2 and parameter, or null if none evaluate to true.

      Example using a Java 8 lambda expression: 

       Person person =
     people.detectWith((person, fullName) -> person.getFullName().equals(fullName), "John Smith");

      Example using an anonymous inner class: 

       Person person =
     people.detectWith(new Predicate2<Person, String>()
     {
         public boolean accept(Person person, String fullName)
         {
             return person.getFullName().equals(fullName);
         }
     }, "John Smith");
      Specified by:
      detectWith in interface RichIterable<K>
      Overrides:
      detectWith in class AbstractMapIterable<K,V>

    • detectOptional

      public Optional<Pair<K,V>> detectOptional(Predicate2<? super K,? super V> predicate)
      Description copied from interface: MapIterable
      Return the first key and value of the map as an Optional for which the predicate evaluates to true when they are given as arguments. The predicate will only be evaluated until such pair is found or until all of the keys and values of the map have been used as arguments. That is, there may be keys and values of the map that are never used as arguments to the predicate. 
       Optional<Pair<City, Person>> detected =
     peopleByCity.detectOptional((city, person)
          -> city.getName().equals("Anytown") && person.getLastName().equals("Smith"));
      Specified by:
      detectOptional in interface MapIterable<K,V>
      Overrides:
      detectOptional in class AbstractMutableMapIterable<K,V>

    • detectOptional

      public Optional<V> detectOptional(Predicate<? super V> predicate)
      Description copied from interface: RichIterable
      Returns the first element of the iterable for which the predicate evaluates to true as an Optional. This method is commonly called find.

      Example using a Java 8 lambda expression: 

       Person person =
     people.detectOptional(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));

      Specified by:
      detectOptional in interface RichIterable<K>
      Overrides:
      detectOptional in class AbstractMapIterable<K,V>

    • detectWithOptional

      public <P> Optional<V> detectWithOptional(Predicate2<? super V,? super P> predicate, P parameter)
      Description copied from interface: RichIterable
      Returns the first element that evaluates to true for the specified predicate2 and parameter as an Optional.

      Example using a Java 8 lambda expression: 

       Optional<Person> person =
     people.detectWithOptional((person, fullName) -> person.getFullName().equals(fullName), "John Smith");

      Specified by:
      detectWithOptional in interface RichIterable<K>
      Overrides:
      detectWithOptional in class AbstractMapIterable<K,V>

    • detectIfNone

      public V detectIfNone(Predicate<? super V> predicate, Function0<? extends V> function)
      Description copied from interface: RichIterable
      Returns the first element of the iterable for which the predicate evaluates to true. If no element matches the predicate, then returns the value of applying the specified function.
      Specified by:
      detectIfNone in interface RichIterable<K>
      Overrides:
      detectIfNone in class AbstractMapIterable<K,V>

    • detectWithIfNone

      public <P> V detectWithIfNone(Predicate2<? super V,? super P> predicate, P parameter, Function0<? extends V> function)
      Description copied from interface: RichIterable
      Returns the first element of the iterable that evaluates to true for the specified predicate2 and parameter, or returns the value of evaluating the specified function.
      Specified by:
      detectWithIfNone in interface RichIterable<K>
      Overrides:
      detectWithIfNone in class AbstractMapIterable<K,V>

    • anySatisfy

      public boolean anySatisfy(Predicate<? super V> predicate)
      Description copied from interface: RichIterable
      Returns true if the predicate evaluates to true for any element of the iterable. Returns false if the iterable is empty, or if no element returned true when evaluating the predicate.
      Specified by:
      anySatisfy in interface RichIterable<K>
      Overrides:
      anySatisfy in class AbstractMapIterable<K,V>

    • anySatisfyWith

      public <P> boolean anySatisfyWith(Predicate2<? super V,? super P> predicate, P parameter)
      Description copied from interface: RichIterable
      Returns true if the predicate evaluates to true for any element of the collection, or return false. Returns false if the collection is empty.
      Specified by:
      anySatisfyWith in interface RichIterable<K>
      Overrides:
      anySatisfyWith in class AbstractMapIterable<K,V>

    • allSatisfy

      public boolean allSatisfy(Predicate<? super V> predicate)
      Description copied from interface: RichIterable
      Returns true if the predicate evaluates to true for every element of the iterable or if the iterable is empty. Otherwise, returns false.
      Specified by:
      allSatisfy in interface RichIterable<K>
      Overrides:
      allSatisfy in class AbstractMapIterable<K,V>

    • allSatisfyWith

      public <P> boolean allSatisfyWith(Predicate2<? super V,? super P> predicate, P parameter)
      Description copied from interface: RichIterable
      Returns true if the predicate evaluates to true for every element of the collection, or returns false.
      Specified by:
      allSatisfyWith in interface RichIterable<K>
      Overrides:
      allSatisfyWith in class AbstractMapIterable<K,V>

    • noneSatisfy

      public boolean noneSatisfy(Predicate<? super V> predicate)
      Description copied from interface: RichIterable
      Returns true if the predicate evaluates to false for every element of the iterable or if the iterable is empty. Otherwise, returns false.
      Specified by:
      noneSatisfy in interface RichIterable<K>
      Overrides:
      noneSatisfy in class AbstractMapIterable<K,V>

    • noneSatisfyWith

      public <P> boolean noneSatisfyWith(Predicate2<? super V,? super P> predicate, P parameter)
      Description copied from interface: RichIterable
      Returns true if the predicate evaluates to false for every element of the collection, or return false. Returns true if the collection is empty.
      Specified by:
      noneSatisfyWith in interface RichIterable<K>
      Overrides:
      noneSatisfyWith in class AbstractMapIterable<K,V>

    • 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>