Int2IntHashMap (Agrona)

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

All Implemented Interfaces:

java.util.Map<java.lang.Integer,java.lang.Integer>
```
public class Int2IntHashMap
extends java.lang.Object
implements java.util.Map<java.lang.Integer,java.lang.Integer>
```
A 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.IntIterator

class Int2IntHashMap.KeySet

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

Nested Classes
Modifier and Type	Class and Description
`class`	`Int2IntHashMap.IntIterator`
`class`	`Int2IntHashMap.KeySet`
`class`	`Int2IntHashMap.Values`

Constructor Summary

Constructors
Constructor and Description

Int2IntHashMap(int missingValue)

Int2IntHashMap(int initialCapacity, float loadFactor, int missingValue)

Constructors
Constructor and Description
`Int2IntHashMap(int missingValue)`
`Int2IntHashMap(int initialCapacity, float loadFactor, int missingValue)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`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`	`computeIfAbsent(int key, java.util.function.IntUnaryOperator mappingFunction)` Primitive specialised version of `Map.computeIfAbsent(Object, Function)`
`boolean`	`containsKey(int key)` Int primitive specialised containsKey.
`boolean`	`containsKey(java.lang.Object key)`
`boolean`	`containsValue(int value)`
`boolean`	`containsValue(java.lang.Object value)`
`java.util.Set<java.util.Map.Entry<java.lang.Integer,java.lang.Integer>>`	`entrySet()`
`void`	`forEach(java.util.function.BiConsumer<? super java.lang.Integer,? super java.lang.Integer> action)`
`int`	`get(int key)`
`java.lang.Integer`	`get(java.lang.Object key)`
`void`	`intForEach(IntIntConsumer consumer)` Primitive specialised forEach implementation.
`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`	`minValue()` Get the minimum value stored in the map.
`int`	`missingValue()` The value to be used as a null marker in the map.
`java.lang.Integer`	`put(java.lang.Integer key, java.lang.Integer value)`
`int`	`put(int key, int value)`
`void`	`putAll(java.util.Map<? extends java.lang.Integer,? extends java.lang.Integer> map)`
`int`	`remove(int key)`
`java.lang.Integer`	`remove(java.lang.Object key)`
`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)`
`int`	`size()`
`java.lang.String`	`toString()`
`Int2IntHashMap.Values`	`values()`

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

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

- Constructor Detail
  - Int2IntHashMap
```
public Int2IntHashMap(int missingValue)
```
  - Int2IntHashMap
```
public Int2IntHashMap(int initialCapacity,
                      float loadFactor,
                      int missingValue)
```
- 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.
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - get
```
public int get(int key)
```
  - put
```
public int put(int key,
               int value)
```
  - intForEach
```
public void intForEach(IntIntConsumer consumer)
```
    Primitive specialised forEach implementation.
    NB: Renamed from forEach to avoid overloading on parameter types of lambda expression, which doesn't interplay 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)
```
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Map<java.lang.Integer,java.lang.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,
                           java.util.function.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.
  - get
```
public java.lang.Integer get(java.lang.Object key)
```
    Specified by:
    
    get in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - put
```
public java.lang.Integer put(java.lang.Integer key,
                             java.lang.Integer value)
```
    Specified by:
    
    put in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - forEach
```
public void forEach(java.util.function.BiConsumer<? super java.lang.Integer,? super java.lang.Integer> action)
```
    Specified by:
    
    forEach in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - containsKey
```
public boolean containsKey(java.lang.Object key)
```
    Specified by:
    
    containsKey in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - containsValue
```
public boolean containsValue(java.lang.Object value)
```
    Specified by:
    
    containsValue in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - putAll
```
public void putAll(java.util.Map<? extends java.lang.Integer,? extends java.lang.Integer> map)
```
    Specified by:
    
    putAll in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - keySet
```
public Int2IntHashMap.KeySet keySet()
```
    Specified by:
    
    keySet in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - values
```
public Int2IntHashMap.Values values()
```
    Specified by:
    
    values in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - entrySet
```
public java.util.Set<java.util.Map.Entry<java.lang.Integer,java.lang.Integer>> entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - remove
```
public java.lang.Integer remove(java.lang.Object key)
```
    Specified by:
    
    remove in interface java.util.Map<java.lang.Integer,java.lang.Integer>
  - remove
```
public int remove(int key)
```
  - 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 java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.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

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

Method Detail

missingValue

loadFactor

size

isEmpty

get

put

intForEach

containsKey

containsValue

clear

compact

computeIfAbsent

get

put

forEach

containsKey

containsValue

putAll

keySet

values

entrySet

remove

remove

minValue

maxValue

toString

replace

replace