Package org.agrona.collections

Class Int2ObjectHashMap<V>

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	Description
final class	Int2ObjectHashMap.EntryIterator	Iterator over entries which supports access to unboxed keys via Int2ObjectHashMap.EntryIterator.getIntKey().
final class	Int2ObjectHashMap.EntrySet	Set of entries which supports access via an optionally cached iterator to avoid allocation.
final class	Int2ObjectHashMap.KeyIterator	Iterator over keys which supports access to unboxed keys via Int2ObjectHashMap.KeyIterator.nextInt().
final class	Int2ObjectHashMap.KeySet	Set of keys which supports optionally cached iterators to avoid allocation.
final class	Int2ObjectHashMap.ValueCollection	Collection of values which supports optionally cached iterators to avoid allocation.
final class	Int2ObjectHashMap.ValueIterator	Iterator over values.

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K extends Object,V extends Object>

Constructor Summary

Constructors

Constructor	Description
Int2ObjectHashMap()	Constructs map with MIN_CAPACITY, Hashing.DEFAULT_LOAD_FACTOR and enables caching of iterators.
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.
Int2ObjectHashMap(Int2ObjectHashMap<V> 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.
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(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	compute(Integer key, BiFunction<? super Integer,? super V,? extends V> remappingFunction)
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	computeIfAbsent(Integer key, Function<? super Integer,? extends V> mappingFunction)
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.
V	computeIfPresent(Integer key, BiFunction<? super Integer,? super V,? extends V> remappingFunction)
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<V>.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<V>.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(int key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)	Primitive specialised version of Map.merge(Object, Object, BiFunction).
V	merge(Integer key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
V	put(int key, V value)	Overloaded version of Map.put(Object, Object) that takes a primitive int key.
V	put(Integer key, V value)
void	putAll(Map<? extends Integer,? extends V> map)
void	putAll(Int2ObjectHashMap<? extends V> map)	Put all values from the given map into this one without allocation.
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<V>.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 Details

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 Details

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<V>.KeySet keySet()

Specified by:

keySet in interface Map<Integer,V>

values

public Int2ObjectHashMap<V>.ValueCollection values()

Specified by:

values in interface Map<Integer,V>

entrySet

public Int2ObjectHashMap<V>.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.