Object2ObjectMap (Primitive-Collections 0.8.0 API)

Type Parameters:

T - the keyType of elements maintained by this Collection

V - the keyType of elements maintained by this Collection

All Superinterfaces:

java.util.function.Function<T,V>, java.util.Map<T,V>, UnaryOperator<T,V>

All Known Subinterfaces:

Object2ObjectConcurrentMap<T,V>, Object2ObjectNavigableMap<T,V>, Object2ObjectOrderedMap<T,V>, Object2ObjectSortedMap<T,V>

All Known Implementing Classes:

AbstractObject2ObjectMap, Enum2ObjectMap, ImmutableObject2ObjectOpenHashMap, LinkedEnum2ObjectMap, Object2ObjectArrayMap, Object2ObjectAVLTreeMap, Object2ObjectConcurrentOpenHashMap, Object2ObjectLinkedOpenCustomHashMap, Object2ObjectLinkedOpenHashMap, Object2ObjectMaps.EmptyMap, Object2ObjectMaps.SingletonMap, Object2ObjectMaps.SynchronizedMap, Object2ObjectMaps.SynchronizedNavigableMap, Object2ObjectMaps.SynchronizedOrderedMap, Object2ObjectMaps.SynchronizedSortedMap, Object2ObjectMaps.UnmodifyableMap, Object2ObjectMaps.UnmodifyableNavigableMap, Object2ObjectMaps.UnmodifyableOrderedMap, Object2ObjectMaps.UnmodifyableSortedMap, Object2ObjectOpenCustomHashMap, Object2ObjectOpenHashMap, Object2ObjectRBTreeMap
```
public interface Object2ObjectMap<T,V>
extends java.util.Map<T,V>, UnaryOperator<T,V>
```
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`	`Object2ObjectMap.BuilderCache<T,V>` Builder Cache for allowing to buildMaps
`static interface`	`Object2ObjectMap.Entry<T,V>` Type Specific Map Entry that reduces boxing/unboxing
`static interface`	`Object2ObjectMap.FastEntrySet<T,V>` Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
`static class`	`Object2ObjectMap.MapBuilder` Helper class that reduces the method spam of the Map Class.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default V`	`apply(T key)` Type Specific get function to reduce boxing/unboxing
`static Object2ObjectMap.MapBuilder`	`builder()` Helper Class that allows to create Maps without requiring a to type out the entire implementation or know it.
`default V`	`compute(T key, java.util.function.BiFunction<? super T,? super V,? extends V> mappingFunction)`
`V`	`compute(T key, ObjectObjectUnaryOperator<T,V> mappingFunction)` A Type Specific compute method to reduce boxing/unboxing
`default V`	`computeIfAbsent(T key, java.util.function.Function<? super T,? extends V> mappingFunction)`
`V`	`computeIfAbsent(T key, UnaryOperator<T,V> mappingFunction)` A Type Specific compute method to reduce boxing/unboxing
`default V`	`computeIfPresent(T key, java.util.function.BiFunction<? super T,? super V,? extends V> mappingFunction)`
`V`	`computeIfPresent(T key, ObjectObjectUnaryOperator<T,V> mappingFunction)` A Type Specific compute method to reduce boxing/unboxing
`Object2ObjectMap<T,V>`	`copy()` A Function that does a shallow clone of the Map itself.
`ObjectSet<java.util.Map.Entry<T,V>>`	`entrySet()`
`default void`	`forEach(java.util.function.BiConsumer<? super T,? super V> action)`
`void`	`forEach(ObjectObjectConsumer<T,V> action)` Type Specific forEach method to reduce boxing/unboxing
`V`	`getDefaultReturnValue()` Method to see what the default return value is.
`V`	`getObject(T key)` A Type Specific get method to reduce boxing/unboxing
`ObjectSet<T>`	`keySet()`
`default V`	`merge(T key, V value, java.util.function.BiFunction<? super V,? super V,? extends V> mappingFunction)`
`V`	`merge(T key, V value, ObjectObjectUnaryOperator<V,V> mappingFunction)` A Type Specific merge method to reduce boxing/unboxing
`void`	`mergeAll(Object2ObjectMap<T,V> m, ObjectObjectUnaryOperator<V,V> mappingFunction)` A Bulk method for merging Maps.
`ObjectSet<Object2ObjectMap.Entry<T,V>>`	`object2ObjectEntrySet()` Type Sensitive EntrySet to reduce boxing/unboxing and optionally Temp Object Allocation.
`default V`	`put(Object2ObjectMap.Entry<T,V> entry)` A Helper method that allows to put int a Object2ObjectMap.Entry into a map.
`V`	`put(T key, V value)` Type Specific method to reduce boxing/unboxing of values
`void`	`putAll(Object2ObjectMap<T,V> m)` Type Specific function for the bull putting of values
`default void`	`putAll(T[] keys, V[] values)` Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
`void`	`putAll(T[] keys, V[] 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(Object2ObjectMap<T,V> m)` Type-Specific bulk put method put elements into the map if not present.
`V`	`putIfAbsent(T key, V value)` Type Specific method to reduce boxing/unboxing of values
`V`	`rem(T key)` Type Specific remove function to reduce boxing/unboxing
`V`	`remOrDefault(T key, V defaultValue)` Type-Specific Remove function with a default return value if wanted.
`default V`	`remove(java.lang.Object key)`
`V`	`replace(T key, V value)` A Type Specific replace method to reduce boxing/unboxing replace an existing value
`boolean`	`replace(T key, V oldValue, V newValue)` A Type Specific replace method to replace an existing value
`default void`	`replaceAll(java.util.function.BiFunction<? super T,? super V,? extends V> mappingFunction)`
`void`	`replaceObjects(Object2ObjectMap<T,V> m)` Type-Specific bulk replace method.
`void`	`replaceObjects(ObjectObjectUnaryOperator<T,V> mappingFunction)` A Type Specific mass replace method to reduce boxing/unboxing
`Object2ObjectMap<T,V>`	`setDefaultReturnValue(V v)` Method to define the default return value if a requested key isn't present
`V`	`supplyIfAbsent(T key, ObjectSupplier<V> valueProvider)` A Supplier based computeIfAbsent function to fill the most used usecase of this function
`default Object2ObjectMap<T,V>`	`synchronize()` Creates a Wrapped Map that is Synchronized
`default Object2ObjectMap<T,V>`	`synchronize(java.lang.Object mutex)` Creates a Wrapped Map that is Synchronized
`default Object2ObjectMap<T,V>`	`unmodifiable()` Creates a Wrapped Map that is unmodifiable
`ObjectCollection<V>`	`values()`

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

Methods inherited from interface speiger.src.collections.objects.functions.function.UnaryOperator
andThen, compose, identity

Methods inherited from interface java.util.function.Function
andThen, compose

- Method Detail
  - builder
```
static Object2ObjectMap.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
```
V getDefaultReturnValue()
```
    Method to see what the default return value is.
    
    Returns:
    
    default return value
  - setDefaultReturnValue
```
Object2ObjectMap<T,V> setDefaultReturnValue(V 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
```
Object2ObjectMap<T,V> 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
```
V put(T key,
      V value)
```
    Type Specific method to reduce boxing/unboxing of values
    
    Specified by:
    
    put in interface java.util.Map<T,V>
    
    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)
  - put
```
default V put(Object2ObjectMap.Entry<T,V> entry)
```
    A Helper method that allows to put int a Object2ObjectMap.Entry into a map.
    
    Parameters:
    
    entry - then Entry that should be inserted.
    
    Returns:
    
    the last present value or default return value.
  - putAll
```
default void putAll(T[] keys,
                    V[] 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,
            V[] 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
```
V putIfAbsent(T key,
              V value)
```
    Type Specific method to reduce boxing/unboxing of values
    
    Specified by:
    
    putIfAbsent in interface java.util.Map<T,V>
    
    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(Object2ObjectMap<T,V> m)
```
    Type-Specific bulk put method put elements into the map if not present.
    
    Parameters:
    
    m - elements that should be added if not present.
  - putAll
```
void putAll(Object2ObjectMap<T,V> m)
```
    Type Specific function for the bull putting of values
    
    Parameters:
    
    m - the elements that should be inserted
  - rem
```
V 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 V remove(java.lang.Object key)
```
    Specified by:
    
    remove in interface java.util.Map<T,V>
    
    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.
  - remOrDefault
```
V remOrDefault(T key,
               V 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,
                V oldValue,
                V newValue)
```
    A Type Specific replace method to replace an existing value
    
    Specified by:
    
    replace in interface java.util.Map<T,V>
    
    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
```
V replace(T key,
          V value)
```
    A Type Specific replace method to reduce boxing/unboxing replace an existing value
    
    Specified by:
    
    replace in interface java.util.Map<T,V>
    
    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
  - replaceObjects
```
void replaceObjects(Object2ObjectMap<T,V> m)
```
    Type-Specific bulk replace method. Could be seen as putAllIfPresent
    
    Parameters:
    
    m - elements that should be replaced.
  - replaceObjects
```
void replaceObjects(ObjectObjectUnaryOperator<T,V> mappingFunction)
```
    A Type Specific mass replace method to reduce boxing/unboxing
    
    Parameters:
    
    mappingFunction - operation to replace all values
  - compute
```
V compute(T key,
          ObjectObjectUnaryOperator<T,V> 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
  - computeIfAbsent
```
V computeIfAbsent(T key,
                  UnaryOperator<T,V> 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
  - supplyIfAbsent
```
V supplyIfAbsent(T key,
                 ObjectSupplier<V> 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
  - computeIfPresent
```
V computeIfPresent(T key,
                   ObjectObjectUnaryOperator<T,V> 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
  - merge
```
V merge(T key,
        V value,
        ObjectObjectUnaryOperator<V,V> 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
  - mergeAll
```
void mergeAll(Object2ObjectMap<T,V> m,
              ObjectObjectUnaryOperator<V,V> 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
  - apply
```
default V apply(T key)
```
    Description copied from interface: UnaryOperator
    
    Type Specific get function to reduce boxing/unboxing
    
    Specified by:
    
    apply in interface java.util.function.Function<T,V>
    
    Specified by:
    
    apply in interface UnaryOperator<T,V>
    
    Parameters:
    
    key - the value that should be processed
    
    Returns:
    
    the result of the function
  - getObject
```
V getObject(T key)
```
    A Type Specific get method to reduce boxing/unboxing
    
    Parameters:
    
    key - the key that is searched for
    
    Returns:
    
    the searched value or default return value
  - replaceAll
```
default void replaceAll(java.util.function.BiFunction<? super T,? super V,? extends V> mappingFunction)
```
    Specified by:
    
    replaceAll in interface java.util.Map<T,V>
  - compute
```
default V compute(T key,
                  java.util.function.BiFunction<? super T,? super V,? extends V> mappingFunction)
```
    Specified by:
    
    compute in interface java.util.Map<T,V>
  - computeIfAbsent
```
default V computeIfAbsent(T key,
                          java.util.function.Function<? super T,? extends V> mappingFunction)
```
    Specified by:
    
    computeIfAbsent in interface java.util.Map<T,V>
  - computeIfPresent
```
default V computeIfPresent(T key,
                           java.util.function.BiFunction<? super T,? super V,? extends V> mappingFunction)
```
    Specified by:
    
    computeIfPresent in interface java.util.Map<T,V>
  - merge
```
default V merge(T key,
                V value,
                java.util.function.BiFunction<? super V,? super V,? extends V> mappingFunction)
```
    Specified by:
    
    merge in interface java.util.Map<T,V>
  - forEach
```
void forEach(ObjectObjectConsumer<T,V> 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 V> action)
```
    Specified by:
    
    forEach in interface java.util.Map<T,V>
  - keySet
```
ObjectSet<T> keySet()
```
    Specified by:
    
    keySet in interface java.util.Map<T,V>
  - values
```
ObjectCollection<V> values()
```
    Specified by:
    
    values in interface java.util.Map<T,V>
  - entrySet
```
ObjectSet<java.util.Map.Entry<T,V>> entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<T,V>
  - object2ObjectEntrySet
```
ObjectSet<Object2ObjectMap.Entry<T,V>> object2ObjectEntrySet()
```
    Type Sensitive EntrySet to reduce boxing/unboxing and optionally Temp Object Allocation.
    
    Returns:
    
    a EntrySet of the collection
  - synchronize
```
default Object2ObjectMap<T,V> synchronize()
```
    Creates a Wrapped Map that is Synchronized
    
    Returns:
    
    a new Map that is synchronized
    
    See Also:
    
    Object2ObjectMaps.synchronize(speiger.src.collections.objects.maps.interfaces.Object2ObjectMap<T, V>)
  - synchronize
```
default Object2ObjectMap<T,V> 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:
    
    Object2ObjectMaps.synchronize(speiger.src.collections.objects.maps.interfaces.Object2ObjectMap<T, V>)
  - unmodifiable
```
default Object2ObjectMap<T,V> unmodifiable()
```
    Creates a Wrapped Map that is unmodifiable
    
    Returns:
    
    a new Map Wrapper that is unmodifiable
    
    See Also:
    
    Object2ObjectMaps.unmodifiable(speiger.src.collections.objects.maps.interfaces.Object2ObjectMap<T, V>)

Interface Object2ObjectMap<T,V>

Nested Class Summary

Method Summary

Methods inherited from interface java.util.Map

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

Methods inherited from interface java.util.function.Function

Method Detail

builder

getDefaultReturnValue

setDefaultReturnValue

copy

put

put

putAll

putAll

putIfAbsent

putAllIfAbsent

putAll

rem

remove

remOrDefault

replace

replace

replaceObjects

replaceObjects

compute

computeIfAbsent

supplyIfAbsent

computeIfPresent

merge

mergeAll

apply

getObject

replaceAll

compute

computeIfAbsent

computeIfPresent

merge

forEach

forEach

keySet

values

entrySet

object2ObjectEntrySet

synchronize

synchronize

unmodifiable