Int2ObjectHashMap (Agrona)

java.lang.Object
- org.agrona.collections.Int2ObjectHashMap<V>

Type Parameters:

V - type of values stored in the Map

All Implemented Interfaces:

Map<Integer,V>

Direct Known Subclasses:

Int2NullableObjectHashMap
```
public class Int2ObjectHashMap<V>
extends Object
implements Map<Integer,V>
```
Map implementation specialised for int keys using open addressing and linear probing for cache efficient access.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`Int2ObjectHashMap.EntryIterator` Iterator over entries which supports access to unboxed keys via `Int2ObjectHashMap.EntryIterator.getIntKey()`.
`class`	`Int2ObjectHashMap.EntrySet` Set of entries which supports access via an optionally cached iterator to avoid allocation.
`class`	`Int2ObjectHashMap.KeyIterator` Iterator over keys which supports access to unboxed keys via `Int2ObjectHashMap.KeyIterator.nextInt()`.
`class`	`Int2ObjectHashMap.KeySet` Set of keys which supports optionally cached iterators to avoid allocation.
`class`	`Int2ObjectHashMap.ValueCollection` Collection of values which supports optionally cached iterators to avoid allocation.
`class`	`Int2ObjectHashMap.ValueIterator` Iterator over values.

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

Constructor Summary

Constructors
Constructor and Description
`Int2ObjectHashMap()` Constructs map with `MIN_CAPACITY`, `Hashing.DEFAULT_LOAD_FACTOR` and enables caching of iterators.
`Int2ObjectHashMap(Int2ObjectHashMap<V> mapToCopy)` Copy construct a new map from an existing one.
`Int2ObjectHashMap(int initialCapacity, float loadFactor)` Constructs map with given initial capacity and load factory and enables caching of iterators.
`Int2ObjectHashMap(int initialCapacity, float loadFactor, boolean shouldAvoidAllocation)` Construct a new map allowing a configuration for initial capacity and load factor.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated 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.
`V`	`compute(Integer key, BiFunction<? super Integer,? super V,? extends V> remappingFunction)`
`V`	`compute(int key, IntObjectToObjectFunction<? super V,? extends V> remappingFunction)` Attempts to compute a mapping for the specified key and its current mapped value (or `null` if there is no current mapping).
`V`	`computeIfAbsent(Integer key, Function<? super Integer,? extends V> mappingFunction)`
`V`	`computeIfAbsent(int key, IntFunction<? extends V> 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.
`V`	`computeIfPresent(Integer key, BiFunction<? super Integer,? super V,? extends V> remappingFunction)`
`V`	`computeIfPresent(int key, IntObjectToObjectFunction<? super V,? extends V> remappingFunction)` If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.
`boolean`	`containsKey(int key)` Overloaded version of `Map.containsKey(Object)` that takes a primitive int key.
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Int2ObjectHashMap.EntrySet`	`entrySet()`
`boolean`	`equals(Object o)`
`void`	`forEach(BiConsumer<? super Integer,? super V> action)`
`void`	`forEachInt(IntObjConsumer<V> consumer)` Primitive specialised implementation of `Map.forEach(BiConsumer)`.
`V`	`get(int key)` Overloaded version of `Map.get(Object)` that takes a primitive int key.
`V`	`get(Object key)`
`protected V`	`getMapped(int key)` Get mapped value without boxing the key.
`V`	`getOrDefault(int key, V defaultValue)` Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
`int`	`hashCode()`
`void`	`intForEach(IntObjConsumer<V> consumer)` Deprecated. Use `forEachInt(IntObjConsumer)` instead.
`boolean`	`isEmpty()`
`Int2ObjectHashMap.KeySet`	`keySet()`
`float`	`loadFactor()` Get the load factor beyond which the map will increase size.
`protected Object`	`mapNullValue(Object value)` Interceptor for masking null values.
`V`	`merge(Integer key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)`
`V`	`merge(int key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)` Primitive specialised version of `Map.merge(Object, Object, BiFunction)`.
`V`	`put(Integer key, V value)`
`V`	`put(int key, V value)` Overloaded version of `Map.put(Object, Object)` that takes a primitive int key.
`void`	`putAll(Int2ObjectHashMap<? extends V> map)` Put all values from the given map into this one without allocation.
`void`	`putAll(Map<? extends Integer,? extends V> map)`
`V`	`putIfAbsent(int key, V value)` Primitive specialised version of `Map.putIfAbsent(Object, Object)`.
`V`	`remove(int key)` Overloaded version of `Map.remove(Object)` that takes a primitive int key.
`boolean`	`remove(int key, V value)` Primitive specialised version of `Map.remove(Object, Object)`.
`V`	`remove(Object key)`
`boolean`	`remove(Object key, Object value)`
`V`	`replace(int key, V value)` Primitive specialised version of `Map.replace(Object, Object)`
`boolean`	`replace(int key, V oldValue, V newValue)` Primitive specialised version of `Map.replace(Object, Object, Object)`
`void`	`replaceAll(BiFunction<? super Integer,? super V,? extends V> function)`
`void`	`replaceAllInt(IntObjectToObjectFunction<? super V,? extends V> 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()`
`protected V`	`unmapNullValue(Object value)` Interceptor for unmasking null values.
`Int2ObjectHashMap.ValueCollection`	`values()`

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

Methods inherited from interface java.util.Map
getOrDefault, putIfAbsent, replace, replace

- Constructor Detail
  - Int2ObjectHashMap
```
public Int2ObjectHashMap()
```
    Constructs map with MIN_CAPACITY, Hashing.DEFAULT_LOAD_FACTOR and enables caching of iterators.
  - Int2ObjectHashMap
```
public Int2ObjectHashMap(int initialCapacity,
                         float loadFactor)
```
    Constructs map with given initial capacity and load factory and enables caching of iterators.
    
    Parameters:
    
    initialCapacity - for the backing array
    
    loadFactor - limit for resizing on puts
  - Int2ObjectHashMap
```
public Int2ObjectHashMap(int initialCapacity,
                         float loadFactor,
                         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
    
    shouldAvoidAllocation - should allocation be avoided by caching iterators and map entries.
  - Int2ObjectHashMap
```
public Int2ObjectHashMap(Int2ObjectHashMap<V> mapToCopy)
```
    Copy construct a new map from an existing one.
    
    Parameters:
    
    mapToCopy - for construction.
- Method Detail
  - 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<Integer,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<Integer,V>
  - forEach
```
public void forEach(BiConsumer<? super Integer,? super V> action)
```
    Specified by:
    
    forEach in interface Map<Integer,V>
  - intForEach
```
@Deprecated
public void intForEach(IntObjConsumer<V> consumer)
```
    Deprecated. Use forEachInt(IntObjConsumer) instead.
    
    Use forEachInt(IntObjConsumer) instead.
    
    Parameters:
    
    consumer - a callback called for each key/value pair in the map.
    
    See Also:
    
    forEachInt(IntObjConsumer)
  - forEachInt
```
public void forEachInt(IntObjConsumer<V> consumer)
```
    Primitive specialised implementation of Map.forEach(BiConsumer).
    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(Object key)
```
    Specified by:
    
    containsKey in interface Map<Integer,V>
  - containsKey
```
public boolean containsKey(int key)
```
    Overloaded version of Map.containsKey(Object) that takes a primitive int key.
    
    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<Integer,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<Integer,V>
  - get
```
public V get(int key)
```
    Overloaded version of Map.get(Object) that takes a primitive int key.
    
    Parameters:
    
    key - for indexing the Map.
    
    Returns:
    
    the value if found otherwise null.
  - getOrDefault
```
public V getOrDefault(int key,
                      V 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.
  - getMapped
```
protected V getMapped(int key)
```
    Get mapped value without boxing the key.
    
    Parameters:
    
    key - to get value by.
    
    Returns:
    
    mapped value or null.
  - computeIfAbsent
```
public V computeIfAbsent(Integer key,
                         Function<? super Integer,? extends V> mappingFunction)
```
    Specified by:
    
    computeIfAbsent in interface Map<Integer,V>
  - computeIfAbsent
```
public V computeIfAbsent(int key,
                         IntFunction<? extends V> 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(Object, Function).
    
    Parameters:
    
    key - to search on.
    
    mappingFunction - to provide a value if the get returns null.
    
    Returns:
    
    the value if found otherwise the default.
  - computeIfPresent
```
public V computeIfPresent(Integer key,
                          BiFunction<? super Integer,? super V,? extends V> remappingFunction)
```
    Specified by:
    
    computeIfPresent in interface Map<Integer,V>
  - computeIfPresent
```
public V computeIfPresent(int key,
                          IntObjectToObjectFunction<? super V,? extends V> remappingFunction)
```
    If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.
    If the function returns null, 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 null if none.
  - compute
```
public V compute(Integer key,
                 BiFunction<? super Integer,? super V,? extends V> remappingFunction)
```
    Specified by:
    
    compute in interface Map<Integer,V>
  - compute
```
public V compute(int key,
                 IntObjectToObjectFunction<? super V,? extends V> remappingFunction)
```
    Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping).
    If the function returns null, 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 null if none.
  - merge
```
public V merge(Integer key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)
```
    Specified by:
    
    merge in interface Map<Integer,V>
  - merge
```
public V merge(int key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)
```
    Primitive specialised version of Map.merge(Object, Object, BiFunction).
    
    Parameters:
    
    key - with which the resulting value is to be associated.
    
    value - the non-null 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 null if no value is associated with the key.
  - put
```
public V put(Integer key,
             V value)
```
    Specified by:
    
    put in interface Map<Integer,V>
  - put
```
public V put(int key,
             V 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 null.
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<Integer,V>
  - remove
```
public V remove(int key)
```
    Overloaded version of Map.remove(Object) that takes a primitive int key.
    
    Parameters:
    
    key - for indexing the Map.
    
    Returns:
    
    the value if found otherwise null.
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Specified by:
    
    remove in interface Map<Integer,V>
  - remove
```
public boolean remove(int key,
                      V 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.
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<Integer,V>
  - 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 Integer,? extends V> map)
```
    Specified by:
    
    putAll in interface Map<Integer,V>
  - putAll
```
public void putAll(Int2ObjectHashMap<? extends V> map)
```
    Put all values from the given map into this one without allocation.
    
    Parameters:
    
    map - whose value are to be added.
  - putIfAbsent
```
public V putIfAbsent(int key,
                     V value)
```
    Primitive specialised version of Map.putIfAbsent(Object, Object).
    
    Parameters:
    
    key - with which the specified value is to be associated.
    
    value - to be associated with the specified key.
    
    Returns:
    
    the previous value associated with the specified key, or null if there was no mapping for the key.
  - keySet
```
public Int2ObjectHashMap.KeySet keySet()
```
    Specified by:
    
    keySet in interface Map<Integer,V>
  - values
```
public Int2ObjectHashMap.ValueCollection values()
```
    Specified by:
    
    values in interface Map<Integer,V>
  - entrySet
```
public Int2ObjectHashMap.EntrySet entrySet()
```
    Specified by:
    
    entrySet in interface Map<Integer,V>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Map<Integer,V>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<Integer,V>
    
    Overrides:
    
    hashCode in class Object
  - mapNullValue
```
protected Object mapNullValue(Object value)
```
    Interceptor for masking null values.
    
    Parameters:
    
    value - value to mask.
    
    Returns:
    
    masked value.
  - unmapNullValue
```
protected V unmapNullValue(Object value)
```
    Interceptor for unmasking null values.
    
    Parameters:
    
    value - value to unmask.
    
    Returns:
    
    unmasked value.
  - replace
```
public V replace(int key,
                 V 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 null if there was no mapping for the key.
  - replace
```
public boolean replace(int key,
                       V oldValue,
                       V 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
  - replaceAll
```
public void replaceAll(BiFunction<? super Integer,? super V,? extends V> function)
```
    Specified by:
    
    replaceAll in interface Map<Integer,V>
  - replaceAllInt
```
public void replaceAllInt(IntObjectToObjectFunction<? super V,? extends V> 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.

Class Int2ObjectHashMap<V>

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

Int2ObjectHashMap

Int2ObjectHashMap

Int2ObjectHashMap

Int2ObjectHashMap

Method Detail

loadFactor

capacity

resizeThreshold

size

isEmpty

forEach

intForEach

forEachInt

containsKey

containsKey

containsValue

get

get

getOrDefault

getMapped

computeIfAbsent

computeIfAbsent

computeIfPresent

computeIfPresent

compute

compute

merge

merge

put

put

remove

remove

remove

remove

clear

compact

putAll

putAll

putIfAbsent

keySet

values

entrySet

toString

equals

hashCode

mapNullValue

unmapNullValue

replace

replace

replaceAll

replaceAllInt