Object2DoubleMap (Primitive-Collections 0.2.0 API)

Type Parameters:

T - the type of elements maintained by this Collection

All Superinterfaces:

java.util.Map<T,java.lang.Double>, Object2DoubleFunction<T>, java.util.function.ToDoubleFunction<T>

All Known Subinterfaces:

Object2DoubleNavigableMap<T>, Object2DoubleSortedMap<T>

All Known Implementing Classes:

AbstractObject2DoubleMap, Enum2DoubleMap, LinkedEnum2DoubleMap, Object2DoubleArrayMap, Object2DoubleAVLTreeMap, Object2DoubleLinkedOpenCustomHashMap, Object2DoubleLinkedOpenHashMap, Object2DoubleMaps.EmptyMap, Object2DoubleMaps.SingletonMap, Object2DoubleMaps.SynchronizedMap, Object2DoubleMaps.SynchronizedNavigableMap, Object2DoubleMaps.SynchronizedSortedMap, Object2DoubleMaps.UnmodifyableMap, Object2DoubleMaps.UnmodifyableNavigableMap, Object2DoubleMaps.UnmodifyableSortedMap, Object2DoubleOpenCustomHashMap, Object2DoubleOpenHashMap, Object2DoubleRBTreeMap
```
public interface Object2DoubleMap<T>
extends java.util.Map<T,java.lang.Double>, Object2DoubleFunction<T>
```
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 interface`	`Object2DoubleMap.Entry<T>` Type Specific Map Entry that reduces boxing/unboxing
`static interface`	`Object2DoubleMap.FastEntrySet<T>` Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`double`	`addTo(T key, double value)` A Helper method to add a primitives together.
`void`	`addToAll(Object2DoubleMap<T> m)` A Helper method to bulk add primitives together.
`default java.lang.Double`	`compute(T key, java.util.function.BiFunction<? super T,? super java.lang.Double,? extends java.lang.Double> mappingFunction)`
`double`	`computeDouble(T key, ObjectDoubleUnaryOperator<T> mappingFunction)` A Type Specific compute method to reduce boxing/unboxing
`double`	`computeDoubleIfAbsent(T key, Object2DoubleFunction<T> mappingFunction)` A Type Specific compute method to reduce boxing/unboxing
`double`	`computeDoubleIfPresent(T key, ObjectDoubleUnaryOperator<T> mappingFunction)` A Type Specific compute method to reduce boxing/unboxing
`default java.lang.Double`	`computeIfAbsent(T key, java.util.function.Function<? super T,? extends java.lang.Double> mappingFunction)`
`default java.lang.Double`	`computeIfPresent(T key, java.util.function.BiFunction<? super T,? super java.lang.Double,? extends java.lang.Double> mappingFunction)`
`boolean`	`containsValue(double value)` Type Specific method to reduce boxing/unboxing of values
`default boolean`	`containsValue(java.lang.Object value)`
`ObjectSet<java.util.Map.Entry<T,java.lang.Double>>`	`entrySet()`
`default void`	`forEach(java.util.function.BiConsumer<? super T,? super java.lang.Double> action)`
`void`	`forEach(ObjectDoubleConsumer<T> action)` Type Specific forEach method to reduce boxing/unboxing
`default java.lang.Double`	`get(java.lang.Object key)`
`double`	`getDefaultReturnValue()` Method to see what the default return value is.
`double`	`getDouble(T key)` A Type Specific get method to reduce boxing/unboxing
`default java.lang.Double`	`getOrDefault(java.lang.Object key, java.lang.Double defaultValue)`
`double`	`getOrDefault(T key, double defaultValue)` A Type Specific getOrDefault method to reduce boxing/unboxing
`ObjectSet<T>`	`keySet()`
`default java.lang.Double`	`merge(T key, java.lang.Double value, java.util.function.BiFunction<? super java.lang.Double,? super java.lang.Double,? extends java.lang.Double> mappingFunction)`
`void`	`mergeAllDouble(Object2DoubleMap<T> m, DoubleDoubleUnaryOperator mappingFunction)` A Bulk method for merging Maps.
`double`	`mergeDouble(T key, double value, DoubleDoubleUnaryOperator mappingFunction)` A Type Specific merge method to reduce boxing/unboxing
`ObjectSet<Object2DoubleMap.Entry<T>>`	`object2DoubleEntrySet()` Type Sensitive EntrySet to reduce boxing/unboxing and optionally Temp Object Allocation.
`double`	`put(T key, double value)` Type Specific method to reduce boxing/unboxing of values
`default java.lang.Double`	`put(T key, java.lang.Double value)`
`void`	`putAll(Object2DoubleMap<T> m)` Type Specific function for the bull putting of values
`default void`	`putAll(T[] keys, double[] values)` Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
`void`	`putAll(T[] keys, double[] values, int offset, int size)` Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
`void`	`putAllIfAbsent(Object2DoubleMap<T> m)` Type-Specific bulk put method put elements into the map if not present.
`double`	`putIfAbsent(T key, double value)` Type Specific method to reduce boxing/unboxing of values
`default java.lang.Double`	`putIfAbsent(T key, java.lang.Double value)`
`double`	`rem(T key)` Type Specific remove function to reduce boxing/unboxing
`double`	`remOrDefault(T key, double defaultValue)` Type-Specific Remove function with a default return value if wanted.
`default java.lang.Double`	`remove(java.lang.Object key)`
`default boolean`	`remove(java.lang.Object key, java.lang.Object value)`
`boolean`	`remove(T key, double value)` Type Specific remove function to reduce boxing/unboxing
`double`	`replace(T key, double value)` A Type Specific replace method to reduce boxing/unboxing replace an existing value
`default java.lang.Double`	`replace(T key, java.lang.Double value)`
`boolean`	`replace(T key, double oldValue, double newValue)` A Type Specific replace method to replace an existing value
`default boolean`	`replace(T key, java.lang.Double oldValue, java.lang.Double newValue)`
`default void`	`replaceAll(java.util.function.BiFunction<? super T,? super java.lang.Double,? extends java.lang.Double> mappingFunction)`
`void`	`replaceDoubles(Object2DoubleMap<T> m)` Type-Specific bulk replace method.
`void`	`replaceDoubles(ObjectDoubleUnaryOperator<T> mappingFunction)` A Type Specific mass replace method to reduce boxing/unboxing
`Object2DoubleMap<T>`	`setDefaultReturnValue(double v)` Method to define the default return value if a requested key isn't present
`DoubleCollection`	`values()`

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

Methods inherited from interface speiger.src.collections.objects.functions.function.Object2DoubleFunction
applyAsDouble

- Method Detail
  - getDefaultReturnValue
```
double getDefaultReturnValue()
```
    Method to see what the default return value is.
    
    Returns:
    
    default return value
  - setDefaultReturnValue
```
Object2DoubleMap<T> setDefaultReturnValue(double 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
  - put
```
double put(T key,
           double 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(T[] keys,
                    double[] 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(T[] keys,
            double[] 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)
  - putIfAbsent
```
double putIfAbsent(T key,
                   double 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(Object2DoubleMap<T> 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
```
double addTo(T key,
             double 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(Object2DoubleMap<T> m)
```
    A Helper method to bulk add primitives together.
    
    Parameters:
    
    m - the values that should be added/inserted
  - putAll
```
void putAll(Object2DoubleMap<T> m)
```
    Type Specific function for the bull putting of values
    
    Parameters:
    
    m - the elements that should be inserted
  - containsValue
```
boolean containsValue(double 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<T,java.lang.Double>
    
    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.
  - rem
```
double rem(T 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.Double remove(java.lang.Object key)
```
    Specified by:
    
    remove in interface java.util.Map<T,java.lang.Double>
    
    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 T but just have to support equals with T.
  - remove
```
boolean remove(T key,
               double 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<T,java.lang.Double>
    
    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)
  - remOrDefault
```
double remOrDefault(T key,
                    double 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(T key,
                double oldValue,
                double 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
```
double replace(T key,
               double 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
  - replaceDoubles
```
void replaceDoubles(Object2DoubleMap<T> m)
```
    Type-Specific bulk replace method. Could be seen as putAllIfPresent
    
    Parameters:
    
    m - elements that should be replaced.
  - replaceDoubles
```
void replaceDoubles(ObjectDoubleUnaryOperator<T> mappingFunction)
```
    A Type Specific mass replace method to reduce boxing/unboxing
    
    Parameters:
    
    mappingFunction - operation to replace all values
  - computeDouble
```
double computeDouble(T key,
                     ObjectDoubleUnaryOperator<T> 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
  - computeDoubleIfAbsent
```
double computeDoubleIfAbsent(T key,
                             Object2DoubleFunction<T> 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
  - computeDoubleIfPresent
```
double computeDoubleIfPresent(T key,
                              ObjectDoubleUnaryOperator<T> 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
  - mergeDouble
```
double mergeDouble(T key,
                   double value,
                   DoubleDoubleUnaryOperator 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
  - mergeAllDouble
```
void mergeAllDouble(Object2DoubleMap<T> m,
                    DoubleDoubleUnaryOperator 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
```
default boolean replace(T key,
                        java.lang.Double oldValue,
                        java.lang.Double newValue)
```
    Specified by:
    
    replace in interface java.util.Map<T,java.lang.Double>
  - replace
```
default java.lang.Double replace(T key,
                                 java.lang.Double value)
```
    Specified by:
    
    replace in interface java.util.Map<T,java.lang.Double>
  - getDouble
```
double getDouble(T key)
```
    A Type Specific get method to reduce boxing/unboxing
    
    Specified by:
    
    getDouble in interface Object2DoubleFunction<T>
    
    Parameters:
    
    key - the key that is searched for
    
    Returns:
    
    the searched value or default return value
  - getOrDefault
```
double getOrDefault(T key,
                    double 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
```
default java.lang.Double get(java.lang.Object key)
```
    Specified by:
    
    get in interface java.util.Map<T,java.lang.Double>
  - getOrDefault
```
default java.lang.Double getOrDefault(java.lang.Object key,
                                      java.lang.Double defaultValue)
```
    Specified by:
    
    getOrDefault in interface java.util.Map<T,java.lang.Double>
  - replaceAll
```
default void replaceAll(java.util.function.BiFunction<? super T,? super java.lang.Double,? extends java.lang.Double> mappingFunction)
```
    Specified by:
    
    replaceAll in interface java.util.Map<T,java.lang.Double>
  - compute
```
default java.lang.Double compute(T key,
                                 java.util.function.BiFunction<? super T,? super java.lang.Double,? extends java.lang.Double> mappingFunction)
```
    Specified by:
    
    compute in interface java.util.Map<T,java.lang.Double>
  - computeIfAbsent
```
default java.lang.Double computeIfAbsent(T key,
                                         java.util.function.Function<? super T,? extends java.lang.Double> mappingFunction)
```
    Specified by:
    
    computeIfAbsent in interface java.util.Map<T,java.lang.Double>
  - computeIfPresent
```
default java.lang.Double computeIfPresent(T key,
                                          java.util.function.BiFunction<? super T,? super java.lang.Double,? extends java.lang.Double> mappingFunction)
```
    Specified by:
    
    computeIfPresent in interface java.util.Map<T,java.lang.Double>
  - merge
```
default java.lang.Double merge(T key,
                               java.lang.Double value,
                               java.util.function.BiFunction<? super java.lang.Double,? super java.lang.Double,? extends java.lang.Double> mappingFunction)
```
    Specified by:
    
    merge in interface java.util.Map<T,java.lang.Double>
  - forEach
```
void forEach(ObjectDoubleConsumer<T> action)
```
    Type Specific forEach method to reduce boxing/unboxing
    
    Parameters:
    
    action - processor of the values that are iterator over
  - forEach
```
default void forEach(java.util.function.BiConsumer<? super T,? super java.lang.Double> action)
```
    Specified by:
    
    forEach in interface java.util.Map<T,java.lang.Double>
  - keySet
```
ObjectSet<T> keySet()
```
    Specified by:
    
    keySet in interface java.util.Map<T,java.lang.Double>
  - values
```
DoubleCollection values()
```
    Specified by:
    
    values in interface java.util.Map<T,java.lang.Double>
  - entrySet
```
ObjectSet<java.util.Map.Entry<T,java.lang.Double>> entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<T,java.lang.Double>
  - object2DoubleEntrySet
```
ObjectSet<Object2DoubleMap.Entry<T>> object2DoubleEntrySet()
```
    Type Sensitive EntrySet to reduce boxing/unboxing and optionally Temp Object Allocation.
    
    Returns:
    
    a EntrySet of the collection
  - put
```
default java.lang.Double put(T key,
                             java.lang.Double value)
```
    Specified by:
    
    put in interface java.util.Map<T,java.lang.Double>
  - putIfAbsent
```
default java.lang.Double putIfAbsent(T key,
                                     java.lang.Double value)
```
    Specified by:
    
    putIfAbsent in interface java.util.Map<T,java.lang.Double>

Interface Object2DoubleMap<T>

Nested Class Summary

Method Summary

Methods inherited from interface java.util.Map

Methods inherited from interface speiger.src.collections.objects.functions.function.Object2DoubleFunction

Method Detail

getDefaultReturnValue

setDefaultReturnValue

put

putAll

putAll

putIfAbsent

putAllIfAbsent

addTo

addToAll

putAll

containsValue

containsValue

rem

remove

remove

remove

remOrDefault

replace

replace

replaceDoubles

replaceDoubles

computeDouble

computeDoubleIfAbsent

computeDoubleIfPresent

mergeDouble

mergeAllDouble

replace

replace

getDouble

getOrDefault

get

getOrDefault

replaceAll

compute

computeIfAbsent

computeIfPresent

merge

forEach

forEach

keySet

values

entrySet

object2DoubleEntrySet

put

putIfAbsent