speiger.src.collections.objects.maps.interfaces

Interface Object2ObjectMap<T,V>

Type Parameters:

T - the type of elements maintained by this Collection

V - the type of elements maintained by this Collection

All Superinterfaces:

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

All Known Subinterfaces:

Object2ObjectNavigableMap<T,V>, Object2ObjectSortedMap<T,V>

All Known Implementing Classes:

AbstractObject2ObjectMap, Enum2ObjectMap, LinkedEnum2ObjectMap, Object2ObjectArrayMap, Object2ObjectAVLTreeMap, Object2ObjectLinkedOpenCustomHashMap, Object2ObjectLinkedOpenHashMap, Object2ObjectMaps.EmptyMap, Object2ObjectMaps.SingletonMap, Object2ObjectMaps.SynchronizedMap, Object2ObjectMaps.SynchronizedNavigableMap, Object2ObjectMaps.SynchronizedSortedMap, Object2ObjectMaps.UnmodifyableMap, Object2ObjectMaps.UnmodifyableNavigableMap, Object2ObjectMaps.UnmodifyableSortedMap, Object2ObjectOpenCustomHashMap, Object2ObjectOpenHashMap, Object2ObjectRBTreeMap

public interface Object2ObjectMap<T,V>
extends java.util.Map<T,V>, Object2ObjectFunction<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 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

Method Summary

Modifier and Type	Method and Description
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, Object2ObjectFunction<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
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.
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.
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
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.Object2ObjectFunction

apply, getObject

Methods inherited from interface java.util.function.Function

andThen, compose, identity

Method Detail

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

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)

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,
                  Object2ObjectFunction<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

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

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