Int2ObjectHashMap (Agrona)

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

Type Parameters:

V - type of values stored in the Map

All Implemented Interfaces:

java.io.Serializable, java.util.Map<java.lang.Integer,V>

Direct Known Subclasses:

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

See Also:

Serialized Form

Nested Class Summary

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

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

Constructor Summary

Constructors
Constructor and Description
`Int2ObjectHashMap()`
`Int2ObjectHashMap(Int2ObjectHashMap<V> mapToCopy)` Copy construct a new map from an existing one.
`Int2ObjectHashMap(int initialCapacity, float loadFactor)`
`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
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`	`computeIfAbsent(int key, java.util.function.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.
`boolean`	`containsKey(int key)` Overloaded version of `Map.containsKey(Object)` that takes a primitive int key.
`boolean`	`containsKey(java.lang.Object key)`
`boolean`	`containsValue(java.lang.Object value)`
`Int2ObjectHashMap.EntrySet`	`entrySet()`
`boolean`	`equals(java.lang.Object o)`
`V`	`get(int key)` Overloaded version of `Map.get(Object)` that takes a primitive int key.
`V`	`get(java.lang.Object key)`
`protected V`	`getMapped(int key)`
`int`	`hashCode()`
`boolean`	`isEmpty()`
`Int2ObjectHashMap.KeySet`	`keySet()`
`float`	`loadFactor()` Get the load factor beyond which the map will increase size.
`protected java.lang.Object`	`mapNullValue(java.lang.Object value)`
`V`	`put(java.lang.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(java.util.Map<? extends java.lang.Integer,? extends V> map)`
`V`	`remove(int key)` Overloaded version of `Map.remove(Object)` that takes a primitive int key.
`V`	`remove(java.lang.Object key)`
`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)`
`int`	`resizeThreshold()` Get the actual threshold which when reached the map will resize.
`int`	`size()`
`java.lang.String`	`toString()`
`protected V`	`unmapNullValue(java.lang.Object value)`
`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
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll

- Constructor Detail
  - Int2ObjectHashMap
```
public Int2ObjectHashMap()
```
  - Int2ObjectHashMap
```
public Int2ObjectHashMap(int initialCapacity,
                         float loadFactor)
```
  - 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 java.util.Map<java.lang.Integer,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Map<java.lang.Integer,V>
  - containsKey
```
public boolean containsKey(java.lang.Object key)
```
    Specified by:
    
    containsKey in interface java.util.Map<java.lang.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(java.lang.Object value)
```
    Specified by:
    
    containsValue in interface java.util.Map<java.lang.Integer,V>
  - get
```
public V get(java.lang.Object key)
```
    Specified by:
    
    get in interface java.util.Map<java.lang.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
  - getMapped
```
protected V getMapped(int key)
```
  - computeIfAbsent
```
public V computeIfAbsent(int key,
                         java.util.function.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(K, java.util.function.Function<? super K, ? extends V>).
    
    Parameters:
    
    key - to search on.
    
    mappingFunction - to provide a value if the get returns null.
    
    Returns:
    
    the value if found otherwise the default.
  - put
```
public V put(java.lang.Integer key,
             V value)
```
    Specified by:
    
    put in interface java.util.Map<java.lang.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(java.lang.Object key)
```
    Specified by:
    
    remove in interface java.util.Map<java.lang.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
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Map<java.lang.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(java.util.Map<? extends java.lang.Integer,? extends V> map)
```
    Specified by:
    
    putAll in interface java.util.Map<java.lang.Integer,V>
  - keySet
```
public Int2ObjectHashMap.KeySet keySet()
```
    Specified by:
    
    keySet in interface java.util.Map<java.lang.Integer,V>
  - values
```
public Int2ObjectHashMap.ValueCollection values()
```
    Specified by:
    
    values in interface java.util.Map<java.lang.Integer,V>
  - entrySet
```
public Int2ObjectHashMap.EntrySet entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<java.lang.Integer,V>
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object o)
```
    Specified by:
    
    equals in interface java.util.Map<java.lang.Integer,V>
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface java.util.Map<java.lang.Integer,V>
    
    Overrides:
    
    hashCode in class java.lang.Object
  - mapNullValue
```
protected java.lang.Object mapNullValue(java.lang.Object value)
```
  - unmapNullValue
```
protected V unmapNullValue(java.lang.Object 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

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

containsKey

containsKey

containsValue

get

get

getMapped

computeIfAbsent

put

put

remove

remove

clear

compact

putAll

keySet

values

entrySet

toString

equals

hashCode

mapNullValue

unmapNullValue

replace

replace