public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2ByteOrderedMap
AbstractLong2ByteMap.BasicEntryjava.util.AbstractMap.SimpleEntry<K,V>, java.util.AbstractMap.SimpleImmutableEntry<K,V>Long2ByteOrderedMap.FastOrderedSetLong2ByteMap.BuilderCache, Long2ByteMap.Entry, Long2ByteMap.FastEntrySet, Long2ByteMap.MapBuilder| Constructor and Description |
|---|
Long2ByteArrayMap()
Default Constructor
|
Long2ByteArrayMap(int minCapacity)
Constructor that defines the minimum capacity
|
Long2ByteArrayMap(long[] keys,
byte[] values)
Helper constructor that allow to create a map from unboxed values
|
Long2ByteArrayMap(java.lang.Long[] keys,
java.lang.Byte[] values)
Helper constructor that allow to create a map from boxed values (it will unbox them)
|
Long2ByteArrayMap(long[] keys,
byte[] values,
int length)
Helper constructor that allow to create a map from unboxed values
|
Long2ByteArrayMap(java.lang.Long[] keys,
java.lang.Byte[] values,
int length)
Helper constructor that allow to create a map from boxed values (it will unbox them) with a custom length
|
Long2ByteArrayMap(Long2ByteMap map)
A Type Specific Helper function that allows to create a new Map with exactly the same values as the provided map.
|
Long2ByteArrayMap(java.util.Map<? extends java.lang.Long,? extends java.lang.Byte> map)
A Helper constructor that allows to create a Map with exactly the same values as the provided map.
|
| Modifier and Type | Method and Description |
|---|---|
byte |
addTo(long key,
byte value)
A Helper method to add a primitives together.
|
void |
clear() |
byte |
computeByte(long key,
LongByteUnaryOperator mappingFunction)
A Type Specific compute method to reduce boxing/unboxing
|
byte |
computeByteIfAbsent(long key,
Long2ByteFunction mappingFunction)
A Type Specific compute method to reduce boxing/unboxing
|
byte |
computeByteIfPresent(long key,
LongByteUnaryOperator mappingFunction)
A Type Specific compute method to reduce boxing/unboxing
|
boolean |
containsKey(long key)
Type Specific method to reduce boxing/unboxing of values
|
boolean |
containsKey(java.lang.Object key) |
boolean |
containsValue(byte value)
Type Specific method to reduce boxing/unboxing of values
|
boolean |
containsValue(java.lang.Object value) |
Long2ByteArrayMap |
copy()
A Function that does a shallow clone of the Map itself.
|
byte |
firstByteValue()
A method to get the first Value of a Map.
|
long |
firstLongKey()
A method to get the first Key of a Map.
|
void |
forEach(LongByteConsumer action)
Type Specific forEach method to reduce boxing/unboxing
|
byte |
get(long key)
A Type Specific get method to reduce boxing/unboxing
|
byte |
getAndMoveToFirst(long key)
A Specific get method that allows to move teh given key/value int the first index.
|
byte |
getAndMoveToLast(long key)
A Specific get method that allows to move teh given key/value int the last index.
|
byte |
getOrDefault(long key,
byte defaultValue)
A Type Specific getOrDefault method to reduce boxing/unboxing
|
LongOrderedSet |
keySet() |
byte |
lastByteValue()
A method to get the last Value of a Map.
|
long |
lastLongKey()
A method to get the last Key of a Map.
|
ObjectOrderedSet<Long2ByteMap.Entry> |
long2ByteEntrySet()
Type Sensitive EntrySet to reduce boxing/unboxing and optionally Temp Object Allocation.
|
void |
mergeAllByte(Long2ByteMap m,
ByteByteUnaryOperator mappingFunction)
A Bulk method for merging Maps.
|
byte |
mergeByte(long key,
byte value,
ByteByteUnaryOperator mappingFunction)
A Type Specific merge method to reduce boxing/unboxing
|
boolean |
moveToFirst(long key)
A specific move method to move a given key/value to the first index.
|
boolean |
moveToLast(long key)
A specific move method to move a given key/value to the last index.
|
long |
pollFirstLongKey()
A method to get and remove the first Key of a Map.
|
long |
pollLastLongKey()
A method to get and remove the last Key of a Map.
|
byte |
put(long key,
byte value)
Type Specific method to reduce boxing/unboxing of values
|
byte |
putAndMoveToFirst(long key,
byte value)
A customized put method that allows you to insert into the first index.
|
byte |
putAndMoveToLast(long key,
byte value)
A customized put method that allows you to insert into the last index.
|
byte |
putIfAbsent(long key,
byte value)
Type Specific method to reduce boxing/unboxing of values
|
byte |
remove(long key)
Type Specific remove function to reduce boxing/unboxing
|
boolean |
remove(long key,
byte value)
Type Specific remove function to reduce boxing/unboxing
|
java.lang.Byte |
remove(java.lang.Object key) |
boolean |
remove(java.lang.Object key,
java.lang.Object value) |
byte |
removeOrDefault(long key,
byte defaultValue)
Type-Specific Remove function with a default return value if wanted.
|
byte |
replace(long key,
byte value)
A Type Specific replace method to reduce boxing/unboxing replace an existing value
|
boolean |
replace(long key,
byte oldValue,
byte newValue)
A Type Specific replace method to replace an existing value
|
int |
size() |
byte |
subFrom(long key,
byte value)
A Helper method to subtract from primitive from each other.
|
byte |
supplyByteIfAbsent(long key,
ByteSupplier valueProvider)
A Supplier based computeIfAbsent function to fill the most used usecase of this function
|
ByteCollection |
values() |
addToAll, entrySet, equals, get, getDefaultReturnValue, getOrDefault, hashCode, put, putAll, putAll, putAll, putAll, putAllIfAbsent, replaceBytes, replaceBytes, setDefaultReturnValuesynchronize, synchronize, unmodifiableaddToAll, builder, compute, computeIfAbsent, computeIfPresent, entrySet, forEach, get, getDefaultReturnValue, getOrDefault, merge, put, putAll, putAll, putAll, putAll, putAll, putAllIfAbsent, putIfAbsent, replace, replace, replaceAll, replaceBytes, replaceBytes, setDefaultReturnValuepublic Long2ByteArrayMap()
public Long2ByteArrayMap(int minCapacity)
minCapacity - the minimum capacity the HashMap is allowed to be.java.lang.IllegalStateException - if the minimum capacity is negativepublic Long2ByteArrayMap(java.lang.Long[] keys,
java.lang.Byte[] values)
keys - the keys that should be put into the mapvalues - the values that should be put into the map.java.lang.IllegalStateException - if the keys and values do not match in lengthpublic Long2ByteArrayMap(java.lang.Long[] keys,
java.lang.Byte[] values,
int length)
keys - the keys that should be put into the mapvalues - the values that should be put into the map.length - the amount of values that should be pulled from the arrayjava.lang.IllegalStateException - if the keys and values do not match in lengthpublic Long2ByteArrayMap(long[] keys,
byte[] values)
keys - the keys that should be put into the mapvalues - the values that should be put into the map.java.lang.IllegalStateException - if the keys and values do not match in lenghtpublic Long2ByteArrayMap(long[] keys,
byte[] values,
int length)
keys - the keys that should be put into the mapvalues - the values that should be put into the map.length - the amount of values that should be pulled from the arrayjava.lang.IllegalStateException - if the keys and values do not match in lenghtpublic Long2ByteArrayMap(java.util.Map<? extends java.lang.Long,? extends java.lang.Byte> map)
map - the values that should be present in the mappublic Long2ByteArrayMap(Long2ByteMap map)
map - the values that should be present in the mappublic byte put(long key,
byte value)
Long2ByteMapput in interface Long2ByteMapkey - the key that should be inserted,value - the value that should be insertedMap.put(Object, Object)public byte putIfAbsent(long key,
byte value)
Long2ByteMapputIfAbsent in interface Long2ByteMapkey - the key that should be inserted,value - the value that should be insertedMap.putIfAbsent(Object, Object)public byte addTo(long key,
byte value)
Long2ByteMapaddTo in interface Long2ByteMapkey - the key that should be inserted,value - the value that should be inserted / addedpublic byte subFrom(long key,
byte value)
Long2ByteMapLong2ByteMap.getDefaultReturnValue()
If the fence is reached the element will be automaticall removedsubFrom in interface Long2ByteMapkey - that should be subtract fromvalue - that should be subtractpublic byte putAndMoveToFirst(long key,
byte value)
Long2ByteOrderedMapputAndMoveToFirst in interface Long2ByteOrderedMapkey - the key that should be insertedvalue - the value that should be insertedMap.put(Object, Object)public byte putAndMoveToLast(long key,
byte value)
Long2ByteOrderedMapputAndMoveToLast in interface Long2ByteOrderedMapkey - the key that should be insertedvalue - the value that should be insertedMap.put(Object, Object)public boolean moveToFirst(long key)
Long2ByteOrderedMapmoveToFirst in interface Long2ByteOrderedMapkey - that should be moved to the first indexpublic boolean moveToLast(long key)
Long2ByteOrderedMapmoveToLast in interface Long2ByteOrderedMapkey - that should be moved to the first lastpublic boolean containsKey(long key)
Long2ByteMapcontainsKey in interface Long2ByteMapcontainsKey in class AbstractLong2ByteMapkey - element that is searched forpublic boolean containsValue(byte value)
Long2ByteMapcontainsValue in interface Long2ByteMapcontainsValue in class AbstractLong2ByteMapvalue - element that is searched forpublic boolean containsKey(java.lang.Object key)
containsKey in interface java.util.Map<java.lang.Long,java.lang.Byte>containsKey in interface Long2ByteMapcontainsKey in class java.util.AbstractMap<java.lang.Long,java.lang.Byte>key - that is searched for.Map.containsKey(Object)public boolean containsValue(java.lang.Object value)
containsValue in interface java.util.Map<java.lang.Long,java.lang.Byte>containsValue in interface Long2ByteMapcontainsValue in class java.util.AbstractMap<java.lang.Long,java.lang.Byte>value - that is searched for.Map.containsValue(Object)public byte get(long key)
Long2ByteMapget in interface Long2ByteFunctionget in interface Long2ByteMapkey - the key that is searched forpublic byte getOrDefault(long key,
byte defaultValue)
Long2ByteMapgetOrDefault in interface Long2ByteMapgetOrDefault in class AbstractLong2ByteMapkey - the key that is searched fordefaultValue - the value that should be returned if the key is not presentpublic byte getAndMoveToFirst(long key)
Long2ByteOrderedMapgetAndMoveToFirst in interface Long2ByteOrderedMapkey - that is searched forpublic byte getAndMoveToLast(long key)
Long2ByteOrderedMapgetAndMoveToLast in interface Long2ByteOrderedMapkey - that is searched forpublic long firstLongKey()
Long2ByteOrderedMapfirstLongKey in interface Long2ByteOrderedMappublic long lastLongKey()
Long2ByteOrderedMaplastLongKey in interface Long2ByteOrderedMappublic byte firstByteValue()
Long2ByteOrderedMapfirstByteValue in interface Long2ByteOrderedMappublic byte lastByteValue()
Long2ByteOrderedMaplastByteValue in interface Long2ByteOrderedMappublic long pollFirstLongKey()
Long2ByteOrderedMappollFirstLongKey in interface Long2ByteOrderedMappublic long pollLastLongKey()
Long2ByteOrderedMappollLastLongKey in interface Long2ByteOrderedMappublic byte remove(long key)
Long2ByteMapremove in interface Long2ByteMapkey - the element that should be removedpublic byte removeOrDefault(long key,
byte defaultValue)
Long2ByteMapremoveOrDefault in interface Long2ByteMapkey - the element that should be removeddefaultValue - the value that should be returned if the entry doesn't existMap.remove(Object, Object)public boolean remove(long key,
byte value)
Long2ByteMapremove in interface Long2ByteMapkey - the element that should be removedvalue - the expected value that should be foundMap.remove(Object, Object)public java.lang.Byte remove(java.lang.Object key)
remove in interface java.util.Map<java.lang.Long,java.lang.Byte>remove in interface Long2ByteMapremove in class AbstractLong2ByteMapkey - the element that should be removedMap.remove(Object)public boolean remove(java.lang.Object key,
java.lang.Object value)
remove in interface java.util.Map<java.lang.Long,java.lang.Byte>remove in interface Long2ByteMapkey - the element that should be removedvalue - the expected value that should be foundMap.remove(Object, Object)public void forEach(LongByteConsumer action)
Long2ByteMapforEach in interface Long2ByteMapforEach in class AbstractLong2ByteMapaction - processor of the values that are iterator overpublic LongOrderedSet keySet()
keySet in interface java.util.Map<java.lang.Long,java.lang.Byte>keySet in interface Long2ByteMapkeySet in interface Long2ByteOrderedMapkeySet in class AbstractLong2ByteMappublic ByteCollection values()
values in interface java.util.Map<java.lang.Long,java.lang.Byte>values in interface Long2ByteMapvalues in class AbstractLong2ByteMappublic ObjectOrderedSet<Long2ByteMap.Entry> long2ByteEntrySet()
Long2ByteMaplong2ByteEntrySet in interface Long2ByteMaplong2ByteEntrySet in interface Long2ByteOrderedMappublic boolean replace(long key,
byte oldValue,
byte newValue)
Long2ByteMapreplace in interface Long2ByteMapreplace in class AbstractLong2ByteMapkey - the element that should be searched foroldValue - the expected value to be replacednewValue - the value to replace the oldValue with.public byte replace(long key,
byte value)
Long2ByteMapreplace in interface Long2ByteMapreplace in class AbstractLong2ByteMapkey - the element that should be searched forvalue - the value to replace with.public byte computeByte(long key,
LongByteUnaryOperator mappingFunction)
Long2ByteMapcomputeByte in interface Long2ByteMapcomputeByte in class AbstractLong2ByteMapkey - the key that should be computedmappingFunction - the operator that should generate the valuepublic byte computeByteIfAbsent(long key,
Long2ByteFunction mappingFunction)
Long2ByteMapcomputeByteIfAbsent in interface Long2ByteMapcomputeByteIfAbsent in class AbstractLong2ByteMapkey - the key that should be computedmappingFunction - the operator that should generate the value if not presentpublic byte supplyByteIfAbsent(long key,
ByteSupplier valueProvider)
Long2ByteMapsupplyByteIfAbsent in interface Long2ByteMapsupplyByteIfAbsent in class AbstractLong2ByteMapkey - the key that should be computedvalueProvider - the value if not presentpublic byte computeByteIfPresent(long key,
LongByteUnaryOperator mappingFunction)
Long2ByteMapcomputeByteIfPresent in interface Long2ByteMapcomputeByteIfPresent in class AbstractLong2ByteMapkey - the key that should be computedmappingFunction - the operator that should generate the value if presentpublic byte mergeByte(long key,
byte value,
ByteByteUnaryOperator mappingFunction)
Long2ByteMapmergeByte in interface Long2ByteMapmergeByte in class AbstractLong2ByteMapkey - the key that should be be searched forvalue - the value that should be merged withmappingFunction - the operator that should generate the new Valuepublic void mergeAllByte(Long2ByteMap m, ByteByteUnaryOperator mappingFunction)
Long2ByteMapmergeAllByte in interface Long2ByteMapmergeAllByte in class AbstractLong2ByteMapm - the entries that should be bulk addedmappingFunction - the operator that should generate the new Valuepublic int size()
size in interface java.util.Map<java.lang.Long,java.lang.Byte>size in class java.util.AbstractMap<java.lang.Long,java.lang.Byte>public void clear()
clear in interface java.util.Map<java.lang.Long,java.lang.Byte>clear in class java.util.AbstractMap<java.lang.Long,java.lang.Byte>public Long2ByteArrayMap copy()
Long2ByteMapcopy in interface Long2ByteMapcopy in interface Long2ByteOrderedMapcopy in class AbstractLong2ByteMap