Package org.agrona.collections

Class Object2IntHashMap<K>

java.lang.Object
org.agrona.collections.Object2IntHashMap<K>
Type Parameters:
K - type of keys stored in the Map
All Implemented Interfaces:
Map<K,Integer>
public class Object2IntHashMap<K> extends Object implements Map<K,Integer>
Map implementation specialised for int values using open addressing and linear probing for cache efficient access. The implementation is mirror copy of Int2ObjectHashMap and it also relies on missing value concept from Int2IntHashMap.

  • Constructor Details

    • Object2IntHashMap

      public Object2IntHashMap(int missingValue)
      Construct a map with default capacity and load factor.
      Parameters:
      missingValue - value to be used as a null maker in the map

    • Object2IntHashMap

      public Object2IntHashMap(int initialCapacity, float loadFactor, int missingValue)
      Construct a new map allowing a configuration for initial capacity and load factor.
      Parameters:
      initialCapacity - for the backing array.
      loadFactor - limit for resizing on puts.
      missingValue - value to be used as a null marker in the map.

    • Object2IntHashMap

      public Object2IntHashMap(int initialCapacity, float loadFactor, int missingValue, boolean shouldAvoidAllocation)
      Construct a new map allowing a configuration for initial capacity and load factor.
      Parameters:
      initialCapacity - for the backing array.
      loadFactor - limit for resizing on puts.
      missingValue - value to be used as a null marker in the map.
      shouldAvoidAllocation - should allocation be avoided by caching iterators and map entries.

    • Object2IntHashMap

      public Object2IntHashMap(Object2IntHashMap<K> mapToCopy)
      Copy construct a new map from an existing one.
      Parameters:
      mapToCopy - for construction.

  • Method Details

    • missingValue

      public int missingValue()
      The value to be used as a null marker in the map.
      Returns:
      value to be used as a null marker in the map.

    • loadFactor

      public float loadFactor()
      Get the load factor beyond which the map will increase size.
      Returns:
      load factor for when the map should increase size.

    • capacity

      public int capacity()
      Get the total capacity for the map to which the load factor will be a fraction of.
      Returns:
      the total capacity for the map.

    • resizeThreshold

      public int resizeThreshold()
      Get the actual threshold which when reached the map will resize. This is a function of the current capacity and load factor.
      Returns:
      the threshold when the map will resize.

    • size

      public int size()
      Specified by:
      size in interface Map<K,Integer>

    • isEmpty

      public boolean isEmpty()
      Specified by:
      isEmpty in interface Map<K,Integer>

    • containsKey

      public boolean containsKey(Object key)
      Overloaded version of Map.containsKey(Object) that takes a primitive int key.
      Specified by:
      containsKey in interface Map<K,Integer>
      Parameters:
      key - for indexing the Map.
      Returns:
      true if the key is found otherwise false.

    • containsValue

      public boolean containsValue(Object value)
      Specified by:
      containsValue in interface Map<K,Integer>

    • containsValue

      public boolean containsValue(int value)
      Overloaded version to avoid boxing.
      Parameters:
      value - to check.
      Returns:
      true if the collection contains the value.

    • getOrDefault

      public int getOrDefault(Object key, int defaultValue)
      Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
      Parameters:
      key - whose associated value is to be returned.
      defaultValue - the default mapping of the key.
      Returns:
      the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.

    • get

      public Integer get(Object key)
      Specified by:
      get in interface Map<K,Integer>

    • getValue

      public int getValue(K key)
      Overloaded version of Map.get(Object) that takes a primitive int key. Due to type erasure have to rename the method.
      Parameters:
      key - for indexing the Map.
      Returns:
      the value if found otherwise missingValue.

    • computeIfAbsent

      public int computeIfAbsent(K key, ToIntFunction<? super K> mappingFunction)
      Get a value for a given key, or if it does not exist then default the value via a IntFunction and put it in the map.

      Primitive specialized version of Map.computeIfAbsent(K, java.util.function.Function<? super K, ? extends V>).

      Parameters:
      key - to search on.
      mappingFunction - to provide a value if the get returns missingValue.
      Returns:
      old value if found otherwise the newly computed value.

    • computeIfPresent

      public int computeIfPresent(K key, ObjectIntToIntFunction<? super K> remappingFunction)
      If the value for the specified key is present, attempts to compute a new mapping given the key and its current mapped value.

      If the function returns missingValue, the mapping is removed.

      Primitive specialized version of Map.computeIfPresent(Object, BiFunction).

      Parameters:
      key - to search on.
      remappingFunction - to provide a value if the get returns missingValue.
      Returns:
      the new value associated with the specified key, or missingValue if none.

    • compute

      public int compute(K key, ObjectIntToIntFunction<? super K> remappingFunction)
      Attempts to compute a mapping for the specified key and its current mapped value (or missingValue if there is no current mapping).

      If the function returns missingValue, the mapping is removed (or remains absent if initially absent).

      Primitive specialized version of Map.compute(Object, BiFunction).

      Parameters:
      key - to search on.
      remappingFunction - to provide a value if the get returns missingValue.
      Returns:
      the new value associated with the specified key, or missingValue if none.

    • merge

      public int merge(K key, int value, IntIntFunction remappingFunction)
      If the specified key is not already associated with a value associates it with the given value. Otherwise, replaces the associated value with the results of the given remapping function, or removes if the result is missingValue(). This method may be of use when combining multiple mapped values for a key. If the function returns missingValue() the mapping is removed.

      Primitive specialized version of Map.merge(Object, Object, BiFunction).

      Parameters:
      key - with which the resulting value is to be associated.
      value - to be merged with the existing value associated with the key or, if no existing value is associated with the key, to be associated with the key.
      remappingFunction - the function to recompute a value if present.
      Returns:
      the new value associated with the specified key, or missingValue() if no value is associated with the key.

    • put

      public Integer put(K key, Integer value)
      Specified by:
      put in interface Map<K,Integer>

    • put

      public int put(K key, int value)
      Overloaded version of Map.put(Object, Object) that takes a primitive int key.
      Parameters:
      key - for indexing the Map.
      value - to be inserted in the Map.
      Returns:
      the previous value if found otherwise missingValue.

    • putIfAbsent

      public Integer putIfAbsent(K key, Integer value)
      Specified by:
      putIfAbsent in interface Map<K,Integer>

    • putIfAbsent

      public int putIfAbsent(K key, int value)
      If the specified key is not already associated with a value associates it with the given value and returns missingValue(), else returns the current value.
      Parameters:
      key - with which the specified value is to be associated.
      value - to be associated with the specified key.
      Returns:
      the existing value associated with the specified key, or missingValue() if there was no mapping for the key.
      Throws:
      IllegalArgumentException - if value == missingValue()

    • remove

      public boolean remove(Object key, Object value)
      Specified by:
      remove in interface Map<K,Integer>

    • remove

      public boolean remove(Object key, int value)
      Primitive overload of the Map.remove(Object, Object) that avoids boxing on the value.
      Parameters:
      key - with which the specified value is associated.
      value - expected to be associated with the specified key.
      Returns:
      true if the value was removed.

    • remove

      public Integer remove(Object key)
      Specified by:
      remove in interface Map<K,Integer>

    • removeKey

      public int removeKey(K key)
      Overloaded version of Map.remove(Object) that takes a key and returns a primitive int value. Due to type erasure have to rename the method.
      Parameters:
      key - for indexing the Map.
      Returns:
      the value if found otherwise missingValue.

    • clear

      public void clear()
      Specified by:
      clear in interface Map<K,Integer>

    • compact

      public void compact()
      Compact the Map backing arrays by rehashing with a capacity just larger than current size and giving consideration to the load factor.

    • putAll

      public void putAll(Map<? extends K,? extends Integer> map)
      Specified by:
      putAll in interface Map<K,Integer>

    • putAll

      public void putAll(Object2IntHashMap<? extends K> map)
      Puts all values from the given map to this map.
      Parameters:
      map - whose values to be added to this map.

    • keySet

      public Object2IntHashMap<K>.KeySet keySet()
      Specified by:
      keySet in interface Map<K,Integer>

    • values

      public Object2IntHashMap<K>.ValueCollection values()
      Specified by:
      values in interface Map<K,Integer>

    • entrySet

      public Object2IntHashMap<K>.EntrySet entrySet()
      Specified by:
      entrySet in interface Map<K,Integer>

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(Object o)
      Specified by:
      equals in interface Map<K,Integer>
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface Map<K,Integer>
      Overrides:
      hashCode in class Object

    • replace

      public int replace(K key, int value)
      Primitive specialised version of Map.replace(Object, Object).
      Parameters:
      key - with which the specified value is associated.
      value - to be associated with the specified key.
      Returns:
      the previous value associated with the specified key, or missingValue() if there was no mapping for the key.

    • replace

      public boolean replace(K key, int oldValue, int newValue)
      Primitive specialised version of Map.replace(Object, Object, Object).
      Parameters:
      key - key with which the specified value is associated.
      oldValue - value expected to be associated with the specified key.
      newValue - value to be associated with the specified key.
      Returns:
      true if the value was replaced.

    • replaceAllInt

      public void replaceAllInt(ObjectIntToIntFunction<? super K> function)
      Primitive specialised version of Map.replaceAll(BiFunction).

      NB: Renamed from replaceAll to avoid overloading on parameter types of lambda expression, which doesn't play well with type inference in lambda expressions.

      Parameters:
      function - the function to apply to each entry.

    • forEach

      public void forEach(BiConsumer<? super K,? super Integer> action)
      Specified by:
      forEach in interface Map<K,Integer>

    • forEachInt

      public void forEachInt(ObjIntConsumer<? super K> action)
      Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.
      Parameters:
      action - to be performed for each entry.