Int2IntHashMap (Agrona)

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

All Implemented Interfaces:

Map<Integer,Integer>
```
public class Int2IntHashMap
extends Object
implements Map<Integer,Integer>
```
An open-addressing with linear probing hash map specialised for primitive key and value pairs.

Nested Class Summary

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

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

Constructor Summary

Constructors
Constructor and Description
`Int2IntHashMap(int missingValue)`
`Int2IntHashMap(Int2IntHashMap mapToCopy)` Copy construct a new map from an existing one.
`Int2IntHashMap(int initialCapacity, float loadFactor, int missingValue)`
`Int2IntHashMap(int initialCapacity, float loadFactor, int missingValue, boolean shouldAvoidAllocation)`

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 backing arrays by rehashing with a capacity just larger than current size and giving consideration to the load factor.
`int`	`compute(int key, IntBinaryOperator remappingFunction)` Primitive specialised version of `Map.compute(Object, BiFunction)`.
`int`	`computeIfAbsent(int key, IntUnaryOperator mappingFunction)` Primitive specialised version of `Map.computeIfAbsent(Object, Function)`.
`int`	`computeIfPresent(int key, IntBinaryOperator remappingFunction)` Primitive specialised version of `Map.computeIfPresent(Object, BiFunction)`.
`boolean`	`containsKey(int key)` Int primitive specialised containsKey.
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(int value)` Does the map contain the value.
`boolean`	`containsValue(Object value)`
`Int2IntHashMap.EntrySet`	`entrySet()`
`boolean`	`equals(Object o)`
`void`	`forEach(BiConsumer<? super Integer,? super Integer> action)`
`void`	`forEachInt(IntIntConsumer consumer)` Primitive specialised forEach implementation.
`int`	`get(int key)` Get a value using provided key avoiding boxing.
`Integer`	`get(Object key)`
`int`	`getOrDefault(int key, int 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(IntIntConsumer consumer)` Deprecated. Use `forEachInt(IntIntConsumer)` instead.
`boolean`	`isEmpty()`
`Int2IntHashMap.KeySet`	`keySet()`
`float`	`loadFactor()` Get the load factor applied for resize operations.
`int`	`maxValue()` Get the maximum value stored in the map.
`int`	`merge(int key, int value, IntIntFunction remappingFunction)` Primitive specialised version of `Map.merge(Object, Object, BiFunction)`.
`int`	`minValue()` Get the minimum value stored in the map.
`int`	`missingValue()` The value to be used as a null marker in the map.
`Integer`	`put(Integer key, Integer value)`
`int`	`put(int key, int value)` Put a key value pair in the map.
`void`	`putAll(Int2IntHashMap map)` Put all values from the given map into this map without allocation.
`void`	`putAll(Map<? extends Integer,? extends Integer> map)`
`Integer`	`putIfAbsent(Integer key, Integer value)`
`int`	`putIfAbsent(int key, int value)` Primitive specialised version of `Map.putIfAbsent(Object, Object)` method.
`int`	`remove(int key)` Remove value from the map using given key avoiding boxing.
`boolean`	`remove(int key, int value)` Primitive specialised version of `Map.remove(Object, Object)`.
`Integer`	`remove(Object key)`
`boolean`	`remove(Object key, Object value)`
`Integer`	`replace(Integer key, Integer value)`
`boolean`	`replace(Integer key, Integer oldValue, Integer newValue)`
`int`	`replace(int key, int value)` Primitive specialised version of `Map.replace(Object, Object)`.
`boolean`	`replace(int key, int oldValue, int newValue)` Primitive specialised version of `Map.replace(Object, Object, Object)`.
`void`	`replaceAll(BiFunction<? super Integer,? super Integer,? extends Integer> function)`
`void`	`replaceAllInt(IntIntFunction 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()`
`Int2IntHashMap.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

- Constructor Detail
  - Int2IntHashMap
```
public Int2IntHashMap(int missingValue)
```
    Parameters:
    
    missingValue - for the map that represents null.
  - Int2IntHashMap
```
public Int2IntHashMap(int initialCapacity,
                      float loadFactor,
                      int missingValue)
```
    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.
  - Int2IntHashMap
```
public Int2IntHashMap(int initialCapacity,
                      float loadFactor,
                      int 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.
  - Int2IntHashMap
```
public Int2IntHashMap(Int2IntHashMap mapToCopy)
```
    Copy construct a new map from an existing one.
    
    Parameters:
    
    mapToCopy - for construction.
- Method Detail
  - missingValue
```
public int 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<Integer,Integer>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<Integer,Integer>
  - getOrDefault
```
public int getOrDefault(int key,
                        int 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 int get(int 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 int put(int key,
               int 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 int putIfAbsent(int key,
                       int 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()
  - intForEach
```
@Deprecated
public void intForEach(IntIntConsumer consumer)
```
    Deprecated. Use forEachInt(IntIntConsumer) instead.
    
    Use forEachInt(IntIntConsumer) instead.
    
    Parameters:
    
    consumer - a callback called for each key/value pair in the map.
    
    See Also:
    
    forEachInt(IntIntConsumer)
  - forEachInt
```
public void forEachInt(IntIntConsumer 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(int key)
```
    Int 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(int 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<Integer,Integer>
  - 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 int computeIfAbsent(int key,
                           IntUnaryOperator 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 int computeIfPresent(int key,
                            IntBinaryOperator 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 int compute(int key,
                   IntBinaryOperator 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 Integer get(Object key)
```
    Specified by:
    
    get in interface Map<Integer,Integer>
  - put
```
public Integer put(Integer key,
                   Integer value)
```
    Specified by:
    
    put in interface Map<Integer,Integer>
  - forEach
```
public void forEach(BiConsumer<? super Integer,? super Integer> action)
```
    Specified by:
    
    forEach in interface Map<Integer,Integer>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<Integer,Integer>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<Integer,Integer>
  - putAll
```
public void putAll(Map<? extends Integer,? extends Integer> map)
```
    Specified by:
    
    putAll in interface Map<Integer,Integer>
  - putAll
```
public void putAll(Int2IntHashMap map)
```
    Put all values from the given map into this map without allocation.
    
    Parameters:
    
    map - whose value are to be added.
  - putIfAbsent
```
public Integer putIfAbsent(Integer key,
                           Integer value)
```
    Specified by:
    
    putIfAbsent in interface Map<Integer,Integer>
  - replace
```
public Integer replace(Integer key,
                       Integer value)
```
    Specified by:
    
    replace in interface Map<Integer,Integer>
  - replace
```
public boolean replace(Integer key,
                       Integer oldValue,
                       Integer newValue)
```
    Specified by:
    
    replace in interface Map<Integer,Integer>
  - replaceAll
```
public void replaceAll(BiFunction<? super Integer,? super Integer,? extends Integer> function)
```
    Specified by:
    
    replaceAll in interface Map<Integer,Integer>
  - keySet
```
public Int2IntHashMap.KeySet keySet()
```
    Specified by:
    
    keySet in interface Map<Integer,Integer>
  - values
```
public Int2IntHashMap.ValueCollection values()
```
    Specified by:
    
    values in interface Map<Integer,Integer>
  - entrySet
```
public Int2IntHashMap.EntrySet entrySet()
```
    Specified by:
    
    entrySet in interface Map<Integer,Integer>
  - remove
```
public Integer remove(Object key)
```
    Specified by:
    
    remove in interface Map<Integer,Integer>
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Specified by:
    
    remove in interface Map<Integer,Integer>
  - remove
```
public int remove(int 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(int key,
                      int 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 int merge(int key,
                 int value,
                 IntIntFunction 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 int 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 int 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 int replace(int key,
                   int 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(int key,
                       int oldValue,
                       int 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.
  - replaceAllInt
```
public void replaceAllInt(IntIntFunction 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<Integer,Integer>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<Integer,Integer>
    
    Overrides:
    
    hashCode in class Object

Class Int2IntHashMap

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

Int2IntHashMap

Int2IntHashMap

Int2IntHashMap

Int2IntHashMap

Method Detail

missingValue

loadFactor

capacity

resizeThreshold

size

isEmpty

getOrDefault

get

put

putIfAbsent

intForEach

forEachInt

containsKey

containsValue

clear

compact

computeIfAbsent

computeIfPresent

compute

get

put

forEach

containsKey

containsValue

putAll

putAll

putIfAbsent

replace

replace

replaceAll

keySet

values

entrySet

remove

remove

remove

remove

merge

minValue

maxValue

toString

replace

replace

replaceAllInt

equals

hashCode