Byte2LongMap (Primitive-Collections 0.7.0 API)

All Superinterfaces:

Byte2LongFunction, java.util.Map<java.lang.Byte,java.lang.Long>

All Known Subinterfaces:

Byte2LongConcurrentMap, Byte2LongNavigableMap, Byte2LongOrderedMap, Byte2LongSortedMap

All Known Implementing Classes:

AbstractByte2LongMap, Byte2LongArrayMap, Byte2LongAVLTreeMap, Byte2LongConcurrentOpenHashMap, Byte2LongLinkedOpenCustomHashMap, Byte2LongLinkedOpenHashMap, Byte2LongMaps.EmptyMap, Byte2LongMaps.SingletonMap, Byte2LongMaps.SynchronizedMap, Byte2LongMaps.SynchronizedNavigableMap, Byte2LongMaps.SynchronizedOrderedMap, Byte2LongMaps.SynchronizedSortedMap, Byte2LongMaps.UnmodifyableMap, Byte2LongMaps.UnmodifyableNavigableMap, Byte2LongMaps.UnmodifyableOrderedMap, Byte2LongMaps.UnmodifyableSortedMap, Byte2LongOpenCustomHashMap, Byte2LongOpenHashMap, Byte2LongRBTreeMap, ImmutableByte2LongOpenHashMap
```
public interface Byte2LongMap
extends java.util.Map<java.lang.Byte,java.lang.Long>, Byte2LongFunction
```
A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Byte2LongMap.BuilderCache` Builder Cache for allowing to buildMaps
`static interface`	`Byte2LongMap.Entry` Type Specific Map Entry that reduces boxing/unboxing
`static interface`	`Byte2LongMap.FastEntrySet` Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
`static class`	`Byte2LongMap.MapBuilder` Helper class that reduces the method spam of the Map Class.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`long`	`addTo(byte key, long value)` A Helper method to add a primitives together.
`void`	`addToAll(Byte2LongMap m)` A Helper method to bulk add primitives together.
`static Byte2LongMap.MapBuilder`	`builder()` Helper Class that allows to create Maps without requiring a to type out the entire implementation or know it.
`ObjectSet<Byte2LongMap.Entry>`	`byte2LongEntrySet()` Type Sensitive EntrySet to reduce boxing/unboxing and optionally Temp Object Allocation.
`default java.lang.Long`	`compute(java.lang.Byte key, java.util.function.BiFunction<? super java.lang.Byte,? super java.lang.Long,? extends java.lang.Long> mappingFunction)` Deprecated.
`default java.lang.Long`	`computeIfAbsent(java.lang.Byte key, java.util.function.Function<? super java.lang.Byte,? extends java.lang.Long> mappingFunction)` Deprecated.
`default java.lang.Long`	`computeIfPresent(java.lang.Byte key, java.util.function.BiFunction<? super java.lang.Byte,? super java.lang.Long,? extends java.lang.Long> mappingFunction)` Deprecated.
`long`	`computeLong(byte key, ByteLongUnaryOperator mappingFunction)` A Type Specific compute method to reduce boxing/unboxing
`long`	`computeLongIfAbsent(byte key, Byte2LongFunction mappingFunction)` A Type Specific compute method to reduce boxing/unboxing
`long`	`computeLongIfPresent(byte key, ByteLongUnaryOperator mappingFunction)` A Type Specific compute method to reduce boxing/unboxing
`boolean`	`containsKey(byte key)` Type Specific method to reduce boxing/unboxing of values
`default boolean`	`containsKey(java.lang.Object key)`
`boolean`	`containsValue(long value)` Type Specific method to reduce boxing/unboxing of values
`default boolean`	`containsValue(java.lang.Object value)`
`Byte2LongMap`	`copy()` A Function that does a shallow clone of the Map itself.
`ObjectSet<java.util.Map.Entry<java.lang.Byte,java.lang.Long>>`	`entrySet()` Deprecated.
`default void`	`forEach(java.util.function.BiConsumer<? super java.lang.Byte,? super java.lang.Long> action)` Deprecated.
`void`	`forEach(ByteLongConsumer action)` Type Specific forEach method to reduce boxing/unboxing
`long`	`get(byte key)` A Type Specific get method to reduce boxing/unboxing
`default java.lang.Long`	`get(java.lang.Object key)` Deprecated.
`long`	`getDefaultReturnValue()` Method to see what the default return value is.
`long`	`getOrDefault(byte key, long defaultValue)` A Type Specific getOrDefault method to reduce boxing/unboxing
`default java.lang.Long`	`getOrDefault(java.lang.Object key, java.lang.Long defaultValue)` Deprecated.
`ByteSet`	`keySet()`
`default java.lang.Long`	`merge(java.lang.Byte key, java.lang.Long value, java.util.function.BiFunction<? super java.lang.Long,? super java.lang.Long,? extends java.lang.Long> mappingFunction)` Deprecated.
`void`	`mergeAllLong(Byte2LongMap m, LongLongUnaryOperator mappingFunction)` A Bulk method for merging Maps.
`long`	`mergeLong(byte key, long value, LongLongUnaryOperator mappingFunction)` A Type Specific merge method to reduce boxing/unboxing
`long`	`put(byte key, long value)` Type Specific method to reduce boxing/unboxing of values
`default java.lang.Long`	`put(java.lang.Byte key, java.lang.Long value)` Deprecated.
`default void`	`putAll(byte[] keys, long[] values)` Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
`default void`	`putAll(java.lang.Byte[] keys, java.lang.Long[] values)` Type Specific Object array method to bulk add elements into a map without creating a wrapper and increasing performances
`void`	`putAll(byte[] keys, long[] values, int offset, int size)` Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
`void`	`putAll(java.lang.Byte[] keys, java.lang.Long[] values, int offset, int size)` Type Specific Object array method to bulk add elements into a map without creating a wrapper and increasing performances
`void`	`putAll(Byte2LongMap m)` Type Specific function for the bull putting of values
`void`	`putAllIfAbsent(Byte2LongMap m)` Type-Specific bulk put method put elements into the map if not present.
`long`	`putIfAbsent(byte key, long value)` Type Specific method to reduce boxing/unboxing of values
`default java.lang.Long`	`putIfAbsent(java.lang.Byte key, java.lang.Long value)` Deprecated.
`long`	`remove(byte key)` Type Specific remove function to reduce boxing/unboxing
`boolean`	`remove(byte key, long value)` Type Specific remove function to reduce boxing/unboxing
`default java.lang.Long`	`remove(java.lang.Object key)`
`default boolean`	`remove(java.lang.Object key, java.lang.Object value)`
`long`	`removeOrDefault(byte key, long defaultValue)` Type-Specific Remove function with a default return value if wanted.
`long`	`replace(byte key, long value)` A Type Specific replace method to reduce boxing/unboxing replace an existing value
`default java.lang.Long`	`replace(java.lang.Byte key, java.lang.Long value)` Deprecated.
`boolean`	`replace(byte key, long oldValue, long newValue)` A Type Specific replace method to replace an existing value
`default boolean`	`replace(java.lang.Byte key, java.lang.Long oldValue, java.lang.Long newValue)` Deprecated.
`default void`	`replaceAll(java.util.function.BiFunction<? super java.lang.Byte,? super java.lang.Long,? extends java.lang.Long> mappingFunction)` Deprecated.
`void`	`replaceLongs(Byte2LongMap m)` Type-Specific bulk replace method.
`void`	`replaceLongs(ByteLongUnaryOperator mappingFunction)` A Type Specific mass replace method to reduce boxing/unboxing
`Byte2LongMap`	`setDefaultReturnValue(long v)` Method to define the default return value if a requested key isn't present
`long`	`subFrom(byte key, long value)` A Helper method to subtract from primitive from each other.
`long`	`supplyLongIfAbsent(byte key, LongSupplier valueProvider)` A Supplier based computeIfAbsent function to fill the most used usecase of this function
`default Byte2LongMap`	`synchronize()` Creates a Wrapped Map that is Synchronized
`default Byte2LongMap`	`synchronize(java.lang.Object mutex)` Creates a Wrapped Map that is Synchronized
`default Byte2LongMap`	`unmodifiable()` Creates a Wrapped Map that is unmodifiable
`LongCollection`	`values()`

Methods inherited from interface java.util.Map
clear, equals, hashCode, isEmpty, putAll, size

- Method Detail
  - builder
```
static Byte2LongMap.MapBuilder builder()
```
    Helper Class that allows to create Maps without requiring a to type out the entire implementation or know it.
    
    Returns:
    
    a MapBuilder
  - getDefaultReturnValue
```
long getDefaultReturnValue()
```
    Method to see what the default return value is.
    
    Returns:
    
    default return value
  - setDefaultReturnValue
```
Byte2LongMap setDefaultReturnValue(long v)
```
    Method to define the default return value if a requested key isn't present
    
    Parameters:
    
    v - value that should be the default return value
    
    Returns:
    
    itself
  - copy
```
Byte2LongMap copy()
```
    A Function that does a shallow clone of the Map itself. This function is more optimized then a copy constructor since the Map does not have to be unsorted/resorted. It can be compared to Cloneable but with less exception risk
    
    Returns:
    
    a Shallow Copy of the Map
    
    Note:
    
    Wrappers and view Maps will not support this feature
  - put
```
long put(byte key,
         long value)
```
    Type Specific method to reduce boxing/unboxing of values
    
    Parameters:
    
    key - the key that should be inserted,
    
    value - the value that should be inserted
    
    Returns:
    
    the last present value or default return value.
    
    See Also:
    
    Map.put(Object, Object)
  - putAll
```
default void putAll(byte[] keys,
                    long[] values)
```
    Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
    
    Parameters:
    
    keys - the keys that should be added
    
    values - the values that should be added
    
    Throws:
    
    java.lang.IllegalStateException - if the arrays are not the same size
    
    See Also:
    
    Map.putAll(Map)
  - putAll
```
void putAll(byte[] keys,
            long[] values,
            int offset,
            int size)
```
    Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
    
    Parameters:
    
    keys - the keys that should be added
    
    values - the values that should be added
    
    offset - where the to start in the array
    
    size - how many elements should be added
    
    Throws:
    
    java.lang.IllegalStateException - if the arrays are not within the range
    
    See Also:
    
    Map.putAll(Map)
  - putAll
```
default void putAll(java.lang.Byte[] keys,
                    java.lang.Long[] values)
```
    Type Specific Object array method to bulk add elements into a map without creating a wrapper and increasing performances
    
    Parameters:
    
    keys - the keys that should be added
    
    values - the values that should be added
    
    Throws:
    
    java.lang.IllegalStateException - if the arrays are not the same size
    
    See Also:
    
    Map.putAll(Map)
  - putAll
```
void putAll(java.lang.Byte[] keys,
            java.lang.Long[] values,
            int offset,
            int size)
```
    Type Specific Object array method to bulk add elements into a map without creating a wrapper and increasing performances
    
    Parameters:
    
    keys - the keys that should be added
    
    values - the values that should be added
    
    offset - where the to start in the array
    
    size - how many elements should be added
    
    Throws:
    
    java.lang.IllegalStateException - if the arrays are not within the range
    
    See Also:
    
    Map.putAll(Map)
  - putIfAbsent
```
long putIfAbsent(byte key,
                 long value)
```
    Type Specific method to reduce boxing/unboxing of values
    
    Parameters:
    
    key - the key that should be inserted,
    
    value - the value that should be inserted
    
    Returns:
    
    the last present value or default return value.
    
    See Also:
    
    Map.putIfAbsent(Object, Object)
  - putAllIfAbsent
```
void putAllIfAbsent(Byte2LongMap m)
```
    Type-Specific bulk put method put elements into the map if not present.
    
    Parameters:
    
    m - elements that should be added if not present.
  - addTo
```
long addTo(byte key,
           long value)
```
    A Helper method to add a primitives together. If key is not present then this functions as a put.
    
    Parameters:
    
    key - the key that should be inserted,
    
    value - the value that should be inserted / added
    
    Returns:
    
    the last present value or default return value.
  - addToAll
```
void addToAll(Byte2LongMap m)
```
    A Helper method to bulk add primitives together.
    
    Parameters:
    
    m - the values that should be added/inserted
  - subFrom
```
long subFrom(byte key,
             long value)
```
    A Helper method to subtract from primitive from each other. If the key is not present it will just return the defaultValue How the implementation works is that it will subtract from the current value (if not present it will do nothing) and fence it to the getDefaultReturnValue() If the fence is reached the element will be automaticall removed
    
    Parameters:
    
    key - that should be subtract from
    
    value - that should be subtract
    
    Returns:
    
    the last present or default return value
  - putAll
```
void putAll(Byte2LongMap m)
```
    Type Specific function for the bull putting of values
    
    Parameters:
    
    m - the elements that should be inserted
  - containsKey
```
boolean containsKey(byte key)
```
    Type Specific method to reduce boxing/unboxing of values
    
    Parameters:
    
    key - element that is searched for
    
    Returns:
    
    if the key is present
  - containsKey
```
default boolean containsKey(java.lang.Object key)
```
    Specified by:
    
    containsKey in interface java.util.Map<java.lang.Byte,java.lang.Long>
    
    Parameters:
    
    key - that is searched for.
    
    Returns:
    
    true if found
    
    See Also:
    
    Map.containsKey(Object)
    
    Note:
    
    in some implementations key does not have to be Byte but just have to support equals with Byte.
  - containsValue
```
boolean containsValue(long value)
```
    Type Specific method to reduce boxing/unboxing of values
    
    Parameters:
    
    value - element that is searched for
    
    Returns:
    
    if the value is present
  - containsValue
```
default boolean containsValue(java.lang.Object value)
```
    Specified by:
    
    containsValue in interface java.util.Map<java.lang.Byte,java.lang.Long>
    
    Parameters:
    
    value - that is searched for.
    
    Returns:
    
    true if found
    
    See Also:
    
    Map.containsValue(Object)
    
    Note:
    
    in some implementations key does not have to be CLASS_VALUE but just have to support equals with CLASS_VALUE.
  - remove
```
long remove(byte key)
```
    Type Specific remove function to reduce boxing/unboxing
    
    Parameters:
    
    key - the element that should be removed
    
    Returns:
    
    the value that was removed or default return value
  - remove
```
default java.lang.Long remove(java.lang.Object key)
```
    Specified by:
    
    remove in interface java.util.Map<java.lang.Byte,java.lang.Long>
    
    Parameters:
    
    key - the element that should be removed
    
    Returns:
    
    the value that was removed or default return value
    
    See Also:
    
    Map.remove(Object)
    
    Note:
    
    in some implementations key does not have to be Byte but just have to support equals with Byte.
  - remove
```
boolean remove(byte key,
               long value)
```
    Type Specific remove function to reduce boxing/unboxing
    
    Parameters:
    
    key - the element that should be removed
    
    value - the expected value that should be found
    
    Returns:
    
    true if the key and value was found and removed
    
    See Also:
    
    Map.remove(Object, Object)
  - remove
```
default boolean remove(java.lang.Object key,
                       java.lang.Object value)
```
    Specified by:
    
    remove in interface java.util.Map<java.lang.Byte,java.lang.Long>
    
    Parameters:
    
    key - the element that should be removed
    
    value - the expected value that should be found
    
    Returns:
    
    true if the key and value was found and removed
    
    See Also:
    
    Map.remove(Object, Object)
  - removeOrDefault
```
long removeOrDefault(byte key,
                     long defaultValue)
```
    Type-Specific Remove function with a default return value if wanted.
    
    Parameters:
    
    key - the element that should be removed
    
    defaultValue - the value that should be returned if the entry doesn't exist
    
    Returns:
    
    the value that was removed or default value
    
    See Also:
    
    Map.remove(Object, Object)
  - replace
```
boolean replace(byte key,
                long oldValue,
                long newValue)
```
    A Type Specific replace method to replace an existing value
    
    Parameters:
    
    key - the element that should be searched for
    
    oldValue - the expected value to be replaced
    
    newValue - the value to replace the oldValue with.
    
    Returns:
    
    true if the value got replaced
    
    Note:
    
    this fails if the value is not present even if it matches the oldValue
  - replace
```
long replace(byte key,
             long value)
```
    A Type Specific replace method to reduce boxing/unboxing replace an existing value
    
    Parameters:
    
    key - the element that should be searched for
    
    value - the value to replace with.
    
    Returns:
    
    the present value or default return value
    
    Note:
    
    this fails if the value is not present
  - replaceLongs
```
void replaceLongs(Byte2LongMap m)
```
    Type-Specific bulk replace method. Could be seen as putAllIfPresent
    
    Parameters:
    
    m - elements that should be replaced.
  - replaceLongs
```
void replaceLongs(ByteLongUnaryOperator mappingFunction)
```
    A Type Specific mass replace method to reduce boxing/unboxing
    
    Parameters:
    
    mappingFunction - operation to replace all values
  - computeLong
```
long computeLong(byte key,
                 ByteLongUnaryOperator mappingFunction)
```
    A Type Specific compute method to reduce boxing/unboxing
    
    Parameters:
    
    key - the key that should be computed
    
    mappingFunction - the operator that should generate the value
    
    Returns:
    
    the result of the computation
  - computeLongIfAbsent
```
long computeLongIfAbsent(byte key,
                         Byte2LongFunction mappingFunction)
```
    A Type Specific compute method to reduce boxing/unboxing
    
    Parameters:
    
    key - the key that should be computed
    
    mappingFunction - the operator that should generate the value if not present
    
    Returns:
    
    the result of the computed value or present value
  - supplyLongIfAbsent
```
long supplyLongIfAbsent(byte key,
                        LongSupplier valueProvider)
```
    A Supplier based computeIfAbsent function to fill the most used usecase of this function
    
    Parameters:
    
    key - the key that should be computed
    
    valueProvider - the value if not present
    
    Returns:
    
    the result of the computed value or present value
  - computeLongIfPresent
```
long computeLongIfPresent(byte key,
                          ByteLongUnaryOperator mappingFunction)
```
    A Type Specific compute method to reduce boxing/unboxing
    
    Parameters:
    
    key - the key that should be computed
    
    mappingFunction - the operator that should generate the value if present
    
    Returns:
    
    the result of the default return value or present value
    
    Note:
    
    if not present then compute is not executed
  - mergeLong
```
long mergeLong(byte key,
               long value,
               LongLongUnaryOperator mappingFunction)
```
    A Type Specific merge method to reduce boxing/unboxing
    
    Parameters:
    
    key - the key that should be be searched for
    
    value - the value that should be merged with
    
    mappingFunction - the operator that should generate the new Value
    
    Returns:
    
    the result of the merge
    
    Note:
    
    if the result matches the default return value then the key is removed from the map
  - mergeAllLong
```
void mergeAllLong(Byte2LongMap m,
                  LongLongUnaryOperator mappingFunction)
```
    A Bulk method for merging Maps.
    
    Parameters:
    
    m - the entries that should be bulk added
    
    mappingFunction - the operator that should generate the new Value
    
    Note:
    
    if the result matches the default return value then the key is removed from the map
  - replace
```
@Deprecated
default boolean replace(java.lang.Byte key,
                                     java.lang.Long oldValue,
                                     java.lang.Long newValue)
```
    Deprecated.
    
    Specified by:
    
    replace in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - replace
```
@Deprecated
default java.lang.Long replace(java.lang.Byte key,
                                            java.lang.Long value)
```
    Deprecated.
    
    Specified by:
    
    replace in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - get
```
long get(byte key)
```
    A Type Specific get method to reduce boxing/unboxing
    
    Specified by:
    
    get in interface Byte2LongFunction
    
    Parameters:
    
    key - the key that is searched for
    
    Returns:
    
    the searched value or default return value
  - getOrDefault
```
long getOrDefault(byte key,
                  long defaultValue)
```
    A Type Specific getOrDefault method to reduce boxing/unboxing
    
    Parameters:
    
    key - the key that is searched for
    
    defaultValue - the value that should be returned if the key is not present
    
    Returns:
    
    the searched value or defaultValue value
  - get
```
@Deprecated
default java.lang.Long get(java.lang.Object key)
```
    Deprecated.
    
    Specified by:
    
    get in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - getOrDefault
```
@Deprecated
default java.lang.Long getOrDefault(java.lang.Object key,
                                                 java.lang.Long defaultValue)
```
    Deprecated.
    
    Specified by:
    
    getOrDefault in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - replaceAll
```
@Deprecated
default void replaceAll(java.util.function.BiFunction<? super java.lang.Byte,? super java.lang.Long,? extends java.lang.Long> mappingFunction)
```
    Deprecated.
    
    Specified by:
    
    replaceAll in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - compute
```
@Deprecated
default java.lang.Long compute(java.lang.Byte key,
                                            java.util.function.BiFunction<? super java.lang.Byte,? super java.lang.Long,? extends java.lang.Long> mappingFunction)
```
    Deprecated.
    
    Specified by:
    
    compute in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - computeIfAbsent
```
@Deprecated
default java.lang.Long computeIfAbsent(java.lang.Byte key,
                                                    java.util.function.Function<? super java.lang.Byte,? extends java.lang.Long> mappingFunction)
```
    Deprecated.
    
    Specified by:
    
    computeIfAbsent in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - computeIfPresent
```
@Deprecated
default java.lang.Long computeIfPresent(java.lang.Byte key,
                                                     java.util.function.BiFunction<? super java.lang.Byte,? super java.lang.Long,? extends java.lang.Long> mappingFunction)
```
    Deprecated.
    
    Specified by:
    
    computeIfPresent in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - merge
```
@Deprecated
default java.lang.Long merge(java.lang.Byte key,
                                          java.lang.Long value,
                                          java.util.function.BiFunction<? super java.lang.Long,? super java.lang.Long,? extends java.lang.Long> mappingFunction)
```
    Deprecated.
    
    Specified by:
    
    merge in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - forEach
```
void forEach(ByteLongConsumer action)
```
    Type Specific forEach method to reduce boxing/unboxing
    
    Parameters:
    
    action - processor of the values that are iterator over
  - forEach
```
@Deprecated
default void forEach(java.util.function.BiConsumer<? super java.lang.Byte,? super java.lang.Long> action)
```
    Deprecated.
    
    Specified by:
    
    forEach in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - keySet
```
ByteSet keySet()
```
    Specified by:
    
    keySet in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - values
```
LongCollection values()
```
    Specified by:
    
    values in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - entrySet
```
@Deprecated
ObjectSet<java.util.Map.Entry<java.lang.Byte,java.lang.Long>> entrySet()
```
    Deprecated.
    
    Specified by:
    
    entrySet in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - byte2LongEntrySet
```
ObjectSet<Byte2LongMap.Entry> byte2LongEntrySet()
```
    Type Sensitive EntrySet to reduce boxing/unboxing and optionally Temp Object Allocation.
    
    Returns:
    
    a EntrySet of the collection
  - synchronize
```
default Byte2LongMap synchronize()
```
    Creates a Wrapped Map that is Synchronized
    
    Returns:
    
    a new Map that is synchronized
    
    See Also:
    
    Byte2LongMaps.synchronize(speiger.src.collections.bytes.maps.interfaces.Byte2LongMap)
  - synchronize
```
default Byte2LongMap synchronize(java.lang.Object mutex)
```
    Creates a Wrapped Map that is Synchronized
    
    Parameters:
    
    mutex - is the controller of the synchronization block
    
    Returns:
    
    a new Map Wrapper that is synchronized
    
    See Also:
    
    Byte2LongMaps.synchronize(speiger.src.collections.bytes.maps.interfaces.Byte2LongMap)
  - unmodifiable
```
default Byte2LongMap unmodifiable()
```
    Creates a Wrapped Map that is unmodifiable
    
    Returns:
    
    a new Map Wrapper that is unmodifiable
    
    See Also:
    
    Byte2LongMaps.unmodifiable(speiger.src.collections.bytes.maps.interfaces.Byte2LongMap)
  - put
```
@Deprecated
default java.lang.Long put(java.lang.Byte key,
                                        java.lang.Long value)
```
    Deprecated.
    
    Specified by:
    
    put in interface java.util.Map<java.lang.Byte,java.lang.Long>
  - putIfAbsent
```
@Deprecated
default java.lang.Long putIfAbsent(java.lang.Byte key,
                                                java.lang.Long value)
```
    Deprecated.
    
    Specified by:
    
    putIfAbsent in interface java.util.Map<java.lang.Byte,java.lang.Long>

Interface Byte2LongMap

Nested Class Summary

Method Summary

Methods inherited from interface java.util.Map

Method Detail

builder

getDefaultReturnValue

setDefaultReturnValue

copy

put

putAll

putAll

putAll

putAll

putIfAbsent

putAllIfAbsent

addTo

addToAll

subFrom

putAll

containsKey

containsKey

containsValue

containsValue

remove

remove

remove

remove

removeOrDefault

replace

replace

replaceLongs

replaceLongs

computeLong

computeLongIfAbsent

supplyLongIfAbsent

computeLongIfPresent

mergeLong

mergeAllLong

replace

replace

get

getOrDefault

get

getOrDefault

replaceAll

compute

computeIfAbsent

computeIfPresent

merge

forEach

forEach

keySet

values

entrySet

byte2LongEntrySet

synchronize

synchronize

unmodifiable

put

putIfAbsent