Class Int2IntHashMap

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	Description
(package private) class	Int2IntHashMap.AbstractIterator	Base iterator implementation.
final class	Int2IntHashMap.EntryIterator	Iterator over entries which supports access to unboxed keys and values.
final class	Int2IntHashMap.EntrySet	Set of entries which supports optionally cached iterators to avoid allocation.
final class	Int2IntHashMap.KeyIterator	Iterator over keys which supports access to unboxed keys via Int2IntHashMap.KeyIterator.nextValue().
final class	Int2IntHashMap.KeySet	Set of keys which supports optional cached iterators to avoid allocation.
final class	Int2IntHashMap.ValueCollection	Collection of values which supports optionally cached iterators to avoid allocation.
final class	Int2IntHashMap.ValueIterator	Iterator over values which supports access to unboxed values.

Nested classes/interfaces inherited from interface Map

Map.Entry<K,V>

Field Summary

Fields

Modifier and Type	Field	Description
private int[]	entries
private Int2IntHashMap.EntrySet	entrySet
private Int2IntHashMap.KeySet	keySet
private final float	loadFactor
(package private) static final int	MIN_CAPACITY
private final int	missingValue
private int	resizeThreshold
private final boolean	shouldAvoidAllocation
private int	size
private Int2IntHashMap.ValueCollection	values

Constructor Summary

Constructors

Constructor	Description
Int2IntHashMap(int missingValue)	Create a map instance that does not allocate iterators with a specified missingValue.
Int2IntHashMap(int initialCapacity, float loadFactor, int missingValue)	Create a map instance that does not allocate iterators with specified parameters.
Int2IntHashMap(int initialCapacity, float loadFactor, int missingValue, boolean shouldAvoidAllocation)	Create a map instance with specified parameters.
Int2IntHashMap(Int2IntHashMap mapToCopy)	Copy construct a new map from an existing one.

Method Summary

Modifier and Type	Method	Description
int	capacity()	Get the total capacity for the map to which the load factor will be a fraction of.
private void	capacity(int newCapacity)
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.
private void	compactChain(int deleteKeyIndex)
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()
private void	increaseCapacity()
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.
private static int	next(int index, int mask)
int	put(int key, int value)	Put a key value pair in the map.
Integer	put(Integer key, Integer value)
void	putAll(Map<? extends Integer, ? extends Integer> map)
void	putAll(Int2IntHashMap map)	Put all values from the given map into this map without allocation.
int	putIfAbsent(int key, int value)	Primitive specialised version of Map.putIfAbsent(Object, Object) method.
Integer	putIfAbsent(Integer key, Integer value)
private void	rehash(int newCapacity)
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)
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).
Integer	replace(Integer key, Integer value)
boolean	replace(Integer key, Integer oldValue, Integer newValue)
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()
private Integer	valOrNull(int value)
Int2IntHashMap.ValueCollection	values()

Methods inherited from class Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface Map

compute, computeIfAbsent, computeIfPresent, getOrDefault, merge

Field Details

MIN_CAPACITY

static final int MIN_CAPACITY

See Also:

• Constant Field Values

loadFactor

private final float loadFactor

missingValue

private final int missingValue

resizeThreshold

private int resizeThreshold

size

private int size

shouldAvoidAllocation

private final boolean shouldAvoidAllocation

entries

private int[] entries

keySet

private Int2IntHashMap.KeySet keySet

values

private Int2IntHashMap.ValueCollection values

entrySet

private Int2IntHashMap.EntrySet entrySet

Constructor Details

Int2IntHashMap

public Int2IntHashMap(int missingValue)

Create a map instance that does not allocate iterators with a specified missingValue.

Parameters:

missingValue - for the map that represents null.

Int2IntHashMap

public Int2IntHashMap(int initialCapacity,
 float loadFactor,
 int missingValue)

Create a map instance that does not allocate iterators with specified parameters.

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)

Create a map instance with specified parameters.

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 Details

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()

increaseCapacity

private void increaseCapacity()

rehash

private void rehash(int newCapacity)

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.

compactChain

private void compactChain(int deleteKeyIndex)

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

next

private static int next(int index,
 int mask)

capacity

private void capacity(int newCapacity)

valOrNull

private Integer valOrNull(int value)