Long2LongHashMap (Agrona)

java.lang.Object
- org.agrona.collections.Long2LongHashMap

All Implemented Interfaces:

java.io.Serializable, java.util.Map<java.lang.Long,java.lang.Long>
```
public class Long2LongHashMap
extends java.lang.Object
implements java.util.Map<java.lang.Long,java.lang.Long>, java.io.Serializable
```
A open addressing with linear probing hash map specialised for primitive key and value pairs.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`Long2LongHashMap.EntryIterator`
`class`	`Long2LongHashMap.EntrySet`
`class`	`Long2LongHashMap.KeyIterator`
`class`	`Long2LongHashMap.KeySet`
`class`	`Long2LongHashMap.ValueCollection`
`class`	`Long2LongHashMap.ValueIterator`

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

Constructor Summary

Constructors
Constructor and Description
`Long2LongHashMap(int initialCapacity, float loadFactor, long missingValue)`
`Long2LongHashMap(int initialCapacity, float loadFactor, long missingValue, boolean shouldAvoidAllocation)`
`Long2LongHashMap(long missingValue)`

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 backing arrays by rehashing with a capacity just larger than current size and giving consideration to the load factor.
`long`	`computeIfAbsent(long key, java.util.function.LongUnaryOperator mappingFunction)` Primitive specialised version of `Map.computeIfAbsent(Object, Function)`
`boolean`	`containsKey(long key)` Long primitive specialised containsKey.
`boolean`	`containsKey(java.lang.Object key)`
`boolean`	`containsValue(long value)` Does the map contain the value.
`boolean`	`containsValue(java.lang.Object value)`
`Long2LongHashMap.EntrySet`	`entrySet()`
`boolean`	`equals(java.lang.Object o)`
`void`	`forEach(java.util.function.BiConsumer<? super java.lang.Long,? super java.lang.Long> action)`
`long`	`get(long key)`
`java.lang.Long`	`get(java.lang.Object key)`
`int`	`hashCode()`
`boolean`	`isEmpty()`
`Long2LongHashMap.KeySet`	`keySet()`
`float`	`loadFactor()` Get the load factor applied for resize operations.
`void`	`longForEach(LongLongConsumer consumer)` Primitive specialised forEach implementation.
`long`	`maxValue()` Get the maximum value stored in the map.
`long`	`minValue()` Get the minimum value stored in the map.
`long`	`missingValue()` The value to be used as a null marker in the map.
`long`	`put(long key, long value)` Put a key value pair longo the map.
`java.lang.Long`	`put(java.lang.Long key, java.lang.Long value)`
`void`	`putAll(java.util.Map<? extends java.lang.Long,? extends java.lang.Long> map)`
`long`	`remove(long key)`
`java.lang.Long`	`remove(java.lang.Object key)`
`long`	`replace(long key, long value)` Primitive specialised version of `Map.replace(Object, Object)`
`boolean`	`replace(long key, long oldValue, long newValue)` Primitive specialised version of `Map.replace(Object, Object, Object)`
`int`	`resizeThreshold()` Get the actual threshold which when reached the map will resize.
`int`	`size()`
`java.lang.String`	`toString()`
`Long2LongHashMap.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, putIfAbsent, remove, replace, replace, replaceAll

- Constructor Detail
  - Long2LongHashMap
```
public Long2LongHashMap(long missingValue)
```
  - Long2LongHashMap
```
public Long2LongHashMap(int initialCapacity,
                        float loadFactor,
                        long missingValue)
```
  - Long2LongHashMap
```
public Long2LongHashMap(int initialCapacity,
                        float loadFactor,
                        long missingValue,
                        boolean shouldAvoidAllocation)
```
    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.
- 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 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 java.util.Map<java.lang.Long,java.lang.Long>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Map<java.lang.Long,java.lang.Long>
  - get
```
public long get(long key)
```
  - put
```
public long put(long key,
                long value)
```
    Put a key value pair longo the map.
    
    Parameters:
    
    key - lookup key
    
    value - new value, must not be initialValue
    
    Returns:
    
    current counter value associated with key, or initialValue if none found
    
    Throws:
    
    java.lang.IllegalArgumentException - if value is missingValue
  - longForEach
```
public void longForEach(LongLongConsumer consumer)
```
    Primitive specialised forEach implementation.
    NB: Renamed from forEach to avoid overloading on parameter types of lambda expression, which doesn't longerplay 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 java.util.Map<java.lang.Long,java.lang.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,
                            java.util.function.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.
  - get
```
public java.lang.Long get(java.lang.Object key)
```
    Specified by:
    
    get in interface java.util.Map<java.lang.Long,java.lang.Long>
  - put
```
public java.lang.Long put(java.lang.Long key,
                          java.lang.Long value)
```
    Specified by:
    
    put in interface java.util.Map<java.lang.Long,java.lang.Long>
  - forEach
```
public void forEach(java.util.function.BiConsumer<? super java.lang.Long,? super java.lang.Long> action)
```
    Specified by:
    
    forEach in interface java.util.Map<java.lang.Long,java.lang.Long>
  - containsKey
```
public boolean containsKey(java.lang.Object key)
```
    Specified by:
    
    containsKey in interface java.util.Map<java.lang.Long,java.lang.Long>
  - containsValue
```
public boolean containsValue(java.lang.Object value)
```
    Specified by:
    
    containsValue in interface java.util.Map<java.lang.Long,java.lang.Long>
  - putAll
```
public void putAll(java.util.Map<? extends java.lang.Long,? extends java.lang.Long> map)
```
    Specified by:
    
    putAll in interface java.util.Map<java.lang.Long,java.lang.Long>
  - keySet
```
public Long2LongHashMap.KeySet keySet()
```
    Specified by:
    
    keySet in interface java.util.Map<java.lang.Long,java.lang.Long>
  - values
```
public Long2LongHashMap.ValueCollection values()
```
    Specified by:
    
    values in interface java.util.Map<java.lang.Long,java.lang.Long>
  - entrySet
```
public Long2LongHashMap.EntrySet entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<java.lang.Long,java.lang.Long>
  - remove
```
public java.lang.Long remove(java.lang.Object key)
```
    Specified by:
    
    remove in interface java.util.Map<java.lang.Long,java.lang.Long>
  - remove
```
public long remove(long key)
```
  - 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 java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.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
  - equals
```
public boolean equals(java.lang.Object o)
```
    Specified by:
    
    equals in interface java.util.Map<java.lang.Long,java.lang.Long>
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface java.util.Map<java.lang.Long,java.lang.Long>
    
    Overrides:
    
    hashCode in class java.lang.Object

Class Long2LongHashMap

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

Long2LongHashMap

Long2LongHashMap

Long2LongHashMap

Method Detail

missingValue

loadFactor

capacity

resizeThreshold

size

isEmpty

get

put

longForEach

containsKey

containsValue

clear

compact

computeIfAbsent

get

put

forEach

containsKey

containsValue

putAll

keySet

values

entrySet

remove

remove

minValue

maxValue

toString

replace

replace

equals

hashCode