Package org.agrona.collections

Class Long2LongHashMap

java.lang.Object
org.agrona.collections.Long2LongHashMap
All Implemented Interfaces:
Map<Long,Long>
public class Long2LongHashMap extends Object implements Map<Long,Long>
An open-addressing with linear probing hash map specialised for primitive key and value pairs.

  • Constructor Details

    • Long2LongHashMap

      public Long2LongHashMap(long missingValue)
      Create a map instance that does not allocate iterators with a specified missingValue.
      Parameters:
      missingValue - for the map that represents null.

    • Long2LongHashMap

      public Long2LongHashMap(int initialCapacity, float loadFactor, long missingValue)
      Create a map instance that does not allocate iterators with specified parameters.
      Parameters:
      initialCapacity - for the map to override MIN_CAPACITY
      loadFactor - for the map to override Hashing.DEFAULT_LOAD_FACTOR.
      missingValue - for the map that represents null.

    • Long2LongHashMap

      public Long2LongHashMap(int initialCapacity, float loadFactor, long missingValue, boolean shouldAvoidAllocation)
      Create a map instance with specified parameters.
      Parameters:
      initialCapacity - for the map to override MIN_CAPACITY
      loadFactor - for the map to override Hashing.DEFAULT_LOAD_FACTOR.
      missingValue - for the map that represents null.
      shouldAvoidAllocation - should allocation be avoided by caching iterators and map entries.

    • Long2LongHashMap

      public Long2LongHashMap(Long2LongHashMap mapToCopy)
      Copy construct a new map from an existing one.
      Parameters:
      mapToCopy - for construction.

  • Method Details

    • missingValue

      public long 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 applied for resize operations.
      Returns:
      the load factor applied for resize operations.

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

    • isEmpty

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

    • getOrDefault

      public long getOrDefault(long key, long 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 - to be returned if there is no value in the map for a given key.
      Returns:
      the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.

    • get

      public long get(long key)
      Get a value using provided key avoiding boxing.
      Parameters:
      key - lookup key.
      Returns:
      value associated with the key or missingValue() if key is not found in the map.

    • put

      public long put(long key, long value)
      Put a key value pair in the map.
      Parameters:
      key - lookup key
      value - new value, must not be missingValue()
      Returns:
      previous value associated with the key, or missingValue() if none found
      Throws:
      IllegalArgumentException - if value is missingValue()

    • putIfAbsent

      public long putIfAbsent(long key, long value)
      Primitive specialised version of Map.putIfAbsent(Object, Object) method.
      Parameters:
      key - key with which the specified value is to be associated
      value - 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.
      Throws:
      IllegalArgumentException - if value is missingValue()

    • longForEach

      @Deprecated public void longForEach(LongLongConsumer consumer)
      Deprecated.
      Use forEachLong(LongLongConsumer) instead.
      Use forEachLong(LongLongConsumer) instead.
      Parameters:
      consumer - a callback called for each key/value pair in the map.
      See Also:

    • forEachLong

      public void forEachLong(LongLongConsumer consumer)
      Primitive specialised forEach implementation.

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

      Parameters:
      consumer - a callback called for each key/value pair in the map.

    • containsKey

      public boolean containsKey(long key)
      Long primitive specialised containsKey.
      Parameters:
      key - the key to check.
      Returns:
      true if the map contains key as a key, false otherwise.

    • containsValue

      public boolean containsValue(long value)
      Does the map contain the value.
      Parameters:
      value - to be tested against contained values.
      Returns:
      true if contained otherwise value.

    • clear

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

    • compact

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

    • computeIfAbsent

      public long computeIfAbsent(long key, LongUnaryOperator mappingFunction)
      Primitive specialised version of Map.computeIfAbsent(Object, Function).
      Parameters:
      key - to search on.
      mappingFunction - to provide a value if the get returns null.
      Returns:
      the value if found otherwise the missing value.

    • computeIfPresent

      public long computeIfPresent(long key, LongBinaryOperator remappingFunction)
      Primitive specialised version of Map.computeIfPresent(Object, BiFunction).
      Parameters:
      key - to search on.
      remappingFunction - to compute a value if a mapping is found.
      Returns:
      the updated value if a mapping was found, otherwise the missing value.

    • compute

      public long compute(long key, LongBinaryOperator remappingFunction)
      Primitive specialised version of Map.compute(Object, BiFunction).
      Parameters:
      key - to search on.
      remappingFunction - to compute a value.
      Returns:
      the updated value.

    • get

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

    • put

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

    • forEach

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

    • containsKey

      public boolean containsKey(Object key)
      Specified by:
      containsKey in interface Map<Long,Long>

    • containsValue

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

    • putAll

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

    • putAll

      public void putAll(Long2LongHashMap map)
      Put all values from the given map longo this map without allocation.
      Parameters:
      map - whose value are to be added.

    • putIfAbsent

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

    • replace

      public Long replace(Long key, Long value)
      Specified by:
      replace in interface Map<Long,Long>

    • replace

      public boolean replace(Long key, Long oldValue, Long newValue)
      Specified by:
      replace in interface Map<Long,Long>

    • replaceAll

      public void replaceAll(BiFunction<? super Long,? super Long,? extends Long> function)
      Specified by:
      replaceAll in interface Map<Long,Long>

    • keySet

      public Long2LongHashMap.KeySet keySet()
      Specified by:
      keySet in interface Map<Long,Long>

    • values

      public Long2LongHashMap.ValueCollection values()
      Specified by:
      values in interface Map<Long,Long>

    • entrySet

      public Long2LongHashMap.EntrySet entrySet()
      Specified by:
      entrySet in interface Map<Long,Long>

    • remove

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

    • remove

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

    • remove

      public long remove(long key)
      Remove value from the map using given key avoiding boxing.
      Parameters:
      key - whose mapping is to be removed from the map.
      Returns:
      removed value or missingValue() if key was not found in the map.

    • remove

      public boolean remove(long key, long value)
      Primitive specialised version of Map.remove(Object, Object).
      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.

    • merge

      public long merge(long key, long value, LongLongFunction remappingFunction)
      Primitive specialised 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 or a null 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 as the result of this operation.

    • minValue

      public long minValue()
      Get the minimum value stored in the map. If the map is empty then it will return missingValue().
      Returns:
      the minimum value stored in the map.

    • maxValue

      public long maxValue()
      Get the maximum value stored in the map. If the map is empty then it will return missingValue().
      Returns:
      the maximum value stored in the map.

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • replace

      public long replace(long key, long value)
      Primitive specialised version of Map.replace(Object, Object).
      Parameters:
      key - key with which the specified value is associated.
      value - 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(long key, long oldValue, long 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.

    • replaceAllLong

      public void replaceAllLong(LongLongFunction 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 - to apply to each entry.

    • equals

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

    • hashCode

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