Object2LongHashMap (Agrona)

java.lang.Object
- org.agrona.collections.Object2LongHashMap<K>

Type Parameters:

K - type of keys stored in the Map

All Implemented Interfaces:

Map<K,Long>
```
public class Object2LongHashMap<K>
extends Object
implements Map<K,Long>
```
Map implementation specialised for long values using open addressing and linear probing for cache efficient access. The implementation is mirror copy of Long2ObjectHashMap and it also relies on missing value concept from Long2LongHashMap

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`Object2LongHashMap.EntryIterator` Iterator over entries which can provide unboxed access and optionally avoid allocation.
`class`	`Object2LongHashMap.EntrySet` Set of entries which can optionally cache iterators to avoid allocation.
`class`	`Object2LongHashMap.KeyIterator` Iterator over keys.
`class`	`Object2LongHashMap.KeySet` Set of keys that can optionally cache iterators to avoid allocation.
`class`	`Object2LongHashMap.ValueCollection` Collection of values which can optionally cache iterators to avoid allocation.
`class`	`Object2LongHashMap.ValueIterator` Iterator over values providing unboxed access via `Object2LongHashMap.ValueIterator.nextLong()`.

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

Constructor Summary

Constructors
Constructor and Description
`Object2LongHashMap(int initialCapacity, float loadFactor, long missingValue)` Construct a new map allowing a configuration for initial capacity and load factor.
`Object2LongHashMap(int initialCapacity, float loadFactor, long missingValue, boolean shouldAvoidAllocation)` Construct a new map allowing a configuration for initial capacity and load factor.
`Object2LongHashMap(long missingValue)` Construct a map with default capacity and load factor.
`Object2LongHashMap(Object2LongHashMap<K> mapToCopy)` Copy construct a new map from an existing one.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`capacity()` Get the total capacity for the map to which the load factor will be a fraction of.
`void`	`clear()`
`void`	`compact()` Compact the `Map` backing arrays by rehashing with a capacity just larger than current size and giving consideration to the load factor.
`long`	`compute(K key, ObjectLongToLongFunction<? 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).
`long`	`computeIfAbsent(K key, ToLongFunction<? super K> mappingFunction)` Get a value for a given key, or if it does not exist then default the value via a `LongFunction` and put it in the map.
`long`	`computeIfPresent(K key, ObjectLongToLongFunction<? 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.
`boolean`	`containsKey(Object key)` Overloaded version of `Map.containsKey(Object)` that takes a primitive long key.
`boolean`	`containsValue(long value)` Overloaded version to avoid boxing.
`boolean`	`containsValue(Object value)`
`Object2LongHashMap.EntrySet`	`entrySet()`
`boolean`	`equals(Object o)`
`void`	`forEach(BiConsumer<? super K,? super Long> action)`
`void`	`forEachLong(ObjLongConsumer<? 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.
`Long`	`get(Object key)`
`long`	`getOrDefault(Object key, long defaultValue)` Returns the value to which the specified key is mapped, or `defaultValue` if this map contains no mapping for the key.
`long`	`getValue(K key)` Overloaded version of `Map.get(Object)` that takes a primitive long key.
`int`	`hashCode()`
`boolean`	`isEmpty()`
`Object2LongHashMap.KeySet`	`keySet()`
`float`	`loadFactor()` Get the load factor beyond which the map will increase size.
`long`	`merge(K key, long value, LongLongFunction remappingFunction)` If the specified key is not already associated with a value associates it with the given value.
`long`	`missingValue()` The value to be used as a null marker in the map.
`long`	`put(K key, long value)` Overloaded version of `Map.put(Object, Object)` that takes a primitive long key.
`Long`	`put(K key, Long value)`
`void`	`putAll(Map<? extends K,? extends Long> map)`
`void`	`putAll(Object2LongHashMap<? extends K> map)` Puts all values from the given map to this map.
`long`	`putIfAbsent(K key, long 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.
`Long`	`putIfAbsent(K key, Long value)`
`Long`	`remove(Object key)`
`boolean`	`remove(Object key, long value)` Primitive overload of the `Map.remove(Object, Object)` that avoids boxing on the value.
`boolean`	`remove(Object key, Object value)`
`long`	`removeKey(K key)` Overloaded version of `Map.remove(Object)` that takes a key and returns a primitive long value.
`long`	`replace(K key, long value)` Primitive specialised version of `Map.replace(Object, Object)`
`boolean`	`replace(K key, long oldValue, long newValue)` Primitive specialised version of `Map.replace(Object, Object, Object)`
`void`	`replaceAllLong(ObjectLongToLongFunction<? super K> function)` Primitive specialised version of `Map.replaceAll(BiFunction)`.
`int`	`resizeThreshold()` Get the actual threshold which when reached the map will resize.
`int`	`size()`
`String`	`toString()`
`Object2LongHashMap.ValueCollection`	`values()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

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

- Constructor Detail
  - Object2LongHashMap
```
public Object2LongHashMap(long missingValue)
```
    Construct a map with default capacity and load factor.
    
    Parameters:
    
    missingValue - value to be used as a null maker in the map
  - Object2LongHashMap
```
public Object2LongHashMap(int initialCapacity,
                          float loadFactor,
                          long 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
  - Object2LongHashMap
```
public Object2LongHashMap(int initialCapacity,
                          float loadFactor,
                          long 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.
  - Object2LongHashMap
```
public Object2LongHashMap(Object2LongHashMap<K> mapToCopy)
```
    Copy construct a new map from an existing one.
    
    Parameters:
    
    mapToCopy - for construction.
- Method Detail
  - 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 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,Long>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,Long>
  - containsKey
```
public boolean containsKey(Object key)
```
    Overloaded version of Map.containsKey(Object) that takes a primitive long key.
    
    Specified by:
    
    containsKey in interface Map<K,Long>
    
    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,Long>
  - containsValue
```
public boolean containsValue(long value)
```
    Overloaded version to avoid boxing.
    
    Parameters:
    
    value - to check.
    
    Returns:
    
    true if the collection contains the value.
  - getOrDefault
```
public long getOrDefault(Object 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 - 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 Long get(Object key)
```
    Specified by:
    
    get in interface Map<K,Long>
  - getValue
```
public long getValue(K key)
```
    Overloaded version of Map.get(Object) that takes a primitive long 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 long computeIfAbsent(K key,
                            ToLongFunction<? super K> mappingFunction)
```
    Get a value for a given key, or if it does not exist then default the value via a LongFunction 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 long computeIfPresent(K key,
                             ObjectLongToLongFunction<? 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 long compute(K key,
                    ObjectLongToLongFunction<? 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 long merge(K key,
                  long value,
                  LongLongFunction 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 Long put(K key,
                Long value)
```
    Specified by:
    
    put in interface Map<K,Long>
  - put
```
public long put(K key,
                long value)
```
    Overloaded version of Map.put(Object, Object) that takes a primitive long key.
    
    Parameters:
    
    key - for indexing the Map
    
    value - to be inserted in the Map
    
    Returns:
    
    the previous value if found otherwise missingValue
  - putIfAbsent
```
public Long putIfAbsent(K key,
                        Long value)
```
    Specified by:
    
    putIfAbsent in interface Map<K,Long>
  - putIfAbsent
```
public long putIfAbsent(K key,
                        long 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,Long>
  - remove
```
public boolean remove(Object key,
                      long 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 Long remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,Long>
  - removeKey
```
public long removeKey(K key)
```
    Overloaded version of Map.remove(Object) that takes a key and returns a primitive long 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,Long>
  - 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 Long> map)
```
    Specified by:
    
    putAll in interface Map<K,Long>
  - putAll
```
public void putAll(Object2LongHashMap<? 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 Object2LongHashMap.KeySet keySet()
```
    Specified by:
    
    keySet in interface Map<K,Long>
  - values
```
public Object2LongHashMap.ValueCollection values()
```
    Specified by:
    
    values in interface Map<K,Long>
  - entrySet
```
public Object2LongHashMap.EntrySet entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,Long>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Map<K,Long>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<K,Long>
    
    Overrides:
    
    hashCode in class Object
  - replace
```
public long replace(K key,
                    long 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,
                       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(ObjectLongToLongFunction<? 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 Long> action)
```
    Specified by:
    
    forEach in interface Map<K,Long>
  - forEachLong
```
public void forEachLong(ObjLongConsumer<? 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.

Class Object2LongHashMap<K>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Constructor Detail

Object2LongHashMap

Object2LongHashMap

Object2LongHashMap

Object2LongHashMap

Method Detail

missingValue

loadFactor

capacity

resizeThreshold

size

isEmpty

containsKey

containsValue

containsValue

getOrDefault

get

getValue

computeIfAbsent

computeIfPresent

compute

merge

put

put

putIfAbsent

putIfAbsent

remove

remove

remove

removeKey

clear

compact

putAll

putAll

keySet

values

entrySet

toString

equals

hashCode

replace

replace

replaceAllLong

forEach

forEachLong