K - type of keys stored in the Mappublic class Object2IntHashMap<K> extends Object implements Map<K,Integer>
Map implementation specialised for int values using open addressing and
linear probing for cache efficient access. The implementation is mirror copy of Int2ObjectHashMap
and it also relies on missing value concept from Int2IntHashMap| Modifier and Type | Class and Description |
|---|---|
class |
Object2IntHashMap.EntryIterator
Iterator over entries which can provide unboxed access and optionally avoid allocation.
|
class |
Object2IntHashMap.EntrySet
Set of entries which can optionally cache iterators to avoid allocation.
|
class |
Object2IntHashMap.KeyIterator
Iterator over keys.
|
class |
Object2IntHashMap.KeySet
Set of keys that can optionally cache iterators to avoid allocation.
|
class |
Object2IntHashMap.ValueCollection
Collection of values which can optionally cache iterators to avoid allocation.
|
class |
Object2IntHashMap.ValueIterator
Iterator over values providing unboxed access via
Object2IntHashMap.ValueIterator.nextInt(). |
| Constructor and Description |
|---|
Object2IntHashMap(int missingValue)
Construct a map with default capacity and load factor.
|
Object2IntHashMap(int initialCapacity,
float loadFactor,
int missingValue)
Construct a new map allowing a configuration for initial capacity and load factor.
|
Object2IntHashMap(int initialCapacity,
float loadFactor,
int missingValue,
boolean shouldAvoidAllocation)
Construct a new map allowing a configuration for initial capacity and load factor.
|
Object2IntHashMap(Object2IntHashMap<K> mapToCopy)
Copy construct a new map from an existing one.
|
| 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. |
int |
compute(K key,
ObjectIntToIntFunction<? super K> remappingFunction)
Attempts to compute a mapping for the specified key and its current mapped
value (or missingValue if there is no current mapping).
|
int |
computeIfAbsent(K key,
ToIntFunction<? super K> 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. |
int |
computeIfPresent(K key,
ObjectIntToIntFunction<? super K> remappingFunction)
If the value for the specified key is present, attempts to compute a new
mapping given the key and its current mapped value.
|
boolean |
containsKey(Object key)
Overloaded version of
Map.containsKey(Object) that takes a primitive int key. |
boolean |
containsValue(int value)
Overloaded version to avoid boxing.
|
boolean |
containsValue(Object value) |
Object2IntHashMap.EntrySet |
entrySet() |
boolean |
equals(Object o) |
void |
forEach(BiConsumer<? super K,? super Integer> action) |
void |
forEachInt(ObjIntConsumer<? super K> action)
Performs the given action for each entry in this map until all entries have been processed or the action throws
an exception.
|
Integer |
get(Object key) |
int |
getOrDefault(Object 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 |
getValue(K key)
Overloaded version of
Map.get(Object) that takes a primitive int key. |
int |
hashCode() |
boolean |
isEmpty() |
Object2IntHashMap.KeySet |
keySet() |
float |
loadFactor()
Get the load factor beyond which the map will increase size.
|
int |
merge(K key,
int value,
IntIntFunction remappingFunction)
If the specified key is not already associated with a value associates it with the given value.
|
int |
missingValue()
The value to be used as a null marker in the map.
|
int |
put(K key,
int value)
Overloaded version of
Map.put(Object, Object) that takes a primitive int key. |
Integer |
put(K key,
Integer value) |
void |
putAll(Map<? extends K,? extends Integer> map) |
void |
putAll(Object2IntHashMap<? extends K> map)
Puts all values from the given map to this map.
|
int |
putIfAbsent(K key,
int value)
If the specified key is not already associated with a value associates it with the given value and returns
missingValue(), else returns the current value. |
Integer |
putIfAbsent(K key,
Integer value) |
Integer |
remove(Object key) |
boolean |
remove(Object key,
int value)
Primitive overload of the
Map.remove(Object, Object) that avoids boxing on the value. |
boolean |
remove(Object key,
Object value) |
int |
removeKey(K key)
Overloaded version of
Map.remove(Object) that takes a key and returns a primitive int value. |
int |
replace(K key,
int value)
Primitive specialised version of
Map.replace(Object, Object) |
boolean |
replace(K key,
int oldValue,
int newValue)
Primitive specialised version of
Map.replace(Object, Object, Object) |
void |
replaceAllInt(ObjectIntToIntFunction<? super K> 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() |
Object2IntHashMap.ValueCollection |
values() |
clone, finalize, getClass, notify, notifyAll, wait, wait, waitcompute, computeIfAbsent, computeIfPresent, getOrDefault, merge, replace, replace, replaceAllpublic Object2IntHashMap(int missingValue)
missingValue - value to be used as a null maker in the mappublic Object2IntHashMap(int initialCapacity,
float loadFactor,
int missingValue)
initialCapacity - for the backing arrayloadFactor - limit for resizing on putsmissingValue - value to be used as a null marker in the mappublic Object2IntHashMap(int initialCapacity,
float loadFactor,
int missingValue,
boolean shouldAvoidAllocation)
initialCapacity - for the backing arrayloadFactor - limit for resizing on putsmissingValue - value to be used as a null marker in the mapshouldAvoidAllocation - should allocation be avoided by caching iterators and map entries.public Object2IntHashMap(Object2IntHashMap<K> mapToCopy)
mapToCopy - for construction.public int missingValue()
public float loadFactor()
public int capacity()
public int resizeThreshold()
public boolean containsKey(Object key)
Map.containsKey(Object) that takes a primitive int key.containsKey in interface Map<K,Integer>key - for indexing the Mappublic boolean containsValue(Object value)
containsValue in interface Map<K,Integer>public boolean containsValue(int value)
value - to check.public int getOrDefault(Object key, int defaultValue)
defaultValue if this map contains no mapping
for the key.key - whose associated value is to be returned.defaultValue - the default mapping of the keydefaultValue if this map contains no mapping
for the key.public int getValue(K key)
Map.get(Object) that takes a primitive int key.
Due to type erasure have to rename the methodkey - for indexing the Mappublic int computeIfAbsent(K key, ToIntFunction<? super K> mappingFunction)
IntFunction and put it in the map.
Primitive specialized version of Map.computeIfAbsent(K, java.util.function.Function<? super K, ? extends V>).
key - to search on.mappingFunction - to provide a value if the get returns missingValue.public int computeIfPresent(K key, ObjectIntToIntFunction<? super K> remappingFunction)
If the function returns missingValue, the mapping is removed
Primitive specialized version of Map.computeIfPresent(Object, BiFunction).
key - to search on.remappingFunction - to provide a value if the get returns missingValue.public int compute(K key, ObjectIntToIntFunction<? super K> remappingFunction)
If the function returns missingValue, the mapping is removed (or remains absent if initially absent).
Primitive specialized version of Map.compute(Object, BiFunction).
key - to search on.remappingFunction - to provide a value if the get returns missingValue.public int merge(K key, int value, IntIntFunction remappingFunction)
missingValue(). This method may be of use when combining multiple mapped values for a key. If the
function returns missingValue() the mapping is removed.
Primitive specialized version of Map.merge(Object, Object, BiFunction).
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
is associated with the key, to be associated with the key.remappingFunction - the function to recompute a value if present.missingValue() if no value is associated
with the key.public int put(K key, int value)
Map.put(Object, Object) that takes a primitive int key.public Integer putIfAbsent(K key, Integer value)
putIfAbsent in interface Map<K,Integer>public int putIfAbsent(K key, int value)
missingValue(), else returns the current value.key - with which the specified value is to be associated.value - to be associated with the specified key.missingValue() if there was no mapping
for the key.IllegalArgumentException - if value == missingValue()public boolean remove(Object key, int value)
Map.remove(Object, Object) that avoids boxing on the value.key - with which the specified value is associated.value - expected to be associated with the specified key.true if the value was removed.public int removeKey(K key)
Map.remove(Object) that takes a key and returns a primitive int value.
Due to type erasure have to rename the methodkey - for indexing the Mappublic void compact()
Map backing arrays by rehashing with a capacity just larger than current size
and giving consideration to the load factor.public void putAll(Object2IntHashMap<? extends K> map)
map - whose values to be added to this map.public Object2IntHashMap.KeySet keySet()
public Object2IntHashMap.ValueCollection values()
public Object2IntHashMap.EntrySet entrySet()
public boolean equals(Object o)
public int hashCode()
public int replace(K key, int value)
Map.replace(Object, Object)key - with which the specified value is associated.value - to be associated with the specified key.missingValue() if there was no mapping
for the key.public boolean replace(K key, int oldValue, int newValue)
Map.replace(Object, Object, Object)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.true if the value was replaced.public void replaceAllInt(ObjectIntToIntFunction<? super K> function)
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.
function - the function to apply to each entry.public void forEach(BiConsumer<? super K,? super Integer> action)
public void forEachInt(ObjIntConsumer<? super K> action)
action - to be performed for each entry.Copyright © 2014-2022 Real Logic Limited. All Rights Reserved.