sirius.kernel.commons

Class MultiMap<K,V>

java.lang.Object

sirius.kernel.commons.MultiMap<K,V>

Type Parameters:

K - the key type used by the map

V - the value type used by the map

public class MultiMap<K,V>
extends Object

Represents a map which contains a collection of elements per key.

Provides an implementation which simulates a Map<K, Collection<V>> by providing specific put, get and remove methods.

Field Summary

Fields

Modifier and Type	Field and Description
protected Map<K,Collection<V>>	base

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	MultiMap(Map<K,Collection<V>> base) Used the static factory methods create or createdSynchronized to obtain an instance.

Method Summary

Modifier and Type	Method and Description
void	clear() Removes all entries from this map
static <K,V> MultiMap<K,V>	create() Creates a new MultiMap for the specified types which is not thread safe.
static <K,V> MultiMap<K,V>	createOrdered() Creates a new MultiMap for the specified types which is not thread safe but keeps its insertion order.
static <K,V> MultiMap<K,V>	createSynchronized() Creates a new MultiMap for the specified types which is thread safe.
protected List<V>	createValueList() Can be overridden to specify the subclass of List used to store value lists.
Collection<V>	get(K key) Returns the value list for the given key.
Map<K,Collection<V>>	getUnderlyingMap() Provides direct access to the underlying map.
static <K,V> Collector<V,MultiMap<K,V>,MultiMap<K,V>>	groupingBy(Supplier<MultiMap<K,V>> supplier, Function<V,K> classifier) Creates a Collector which can be used to group a stream into a multi map.
static <K,V> Collector<V,MultiMap<K,V>,MultiMap<K,V>>	groupingByMultiple(Supplier<MultiMap<K,V>> supplier, Function<V,Collection<K>> classifier) Creates a Collector which can be used to group a stream into a multi map.
Set<K>	keySet() Returns the set of known keys.
MultiMap<K,V>	merge(MultiMap<K,V> other) Merges the given multi map into this one.
void	put(K key, V value) Adds the given value to the list of values kept for the given key.
void	remove(K key, V value) Removes all occurrences of the given value in the value list of the given key.
void	set(K key, V value) Sets the given value to the given name.
Stream<Map.Entry<K,Collection<V>>>	stream() Boilerplate method to access all entries of this map as Stream.
String	toString()
List<V>	values() Returns a list of all values for all keys.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

base

protected Map<K,Collection<V>> base

Constructor Detail

MultiMap

protected MultiMap(Map<K,Collection<V>> base)

Used the static factory methods create or createdSynchronized to obtain an instance.

Parameters:

base - the underlying map to use

Method Detail

create

public static <K,V> MultiMap<K,V> create()

Creates a new MultiMap for the specified types which is not thread safe.

Type Parameters:

K - the type of the keys used in the map

V - the type of the values used withing the value lists of the map

Returns:

a new instance of MultiMap which is not thread safe.

createOrdered

public static <K,V> MultiMap<K,V> createOrdered()

Creates a new MultiMap for the specified types which is not thread safe but keeps its insertion order.

Type Parameters:

K - the type of the keys used in the map

V - the type of the values used withing the value lists of the map

Returns:

a new instance of MultiMap which is not thread safe.

createSynchronized

public static <K,V> MultiMap<K,V> createSynchronized()

Creates a new MultiMap for the specified types which is thread safe.

Type Parameters:

K - the type of the keys used in the map

V - the type of the values used withing the value lists of the map

Returns:

a new instance of MultiMap which is thread safe.

put

public void put(@Nonnull
                K key,
                @Nullable
                V value)

Adds the given value to the list of values kept for the given key.

Note that the values for a given key don't from a Set. Therefore adding the same value twice for the same key, will result in having a value list containing the added element twice.

Parameters:

key - the key for which the value is added to the map

value - the value which is added to the list of values for this key

set

public void set(@Nonnull
                K key,
                @Nullable
                V value)

Sets the given value to the given name.

All previously set values will be removed.

Parameters:

key - the key for which the value is added to the map

value - the name (and only) value for the given key

createValueList

protected List<V> createValueList()

Can be overridden to specify the subclass of List used to store value lists.

Returns:

a new instance which is used as value list for a key.

remove

public void remove(@Nonnull
                   K key,
                   @Nullable
                   V value)

Removes all occurrences of the given value in the value list of the given key.

If the value does not occur in the value list or if the key is completely unknown, nothing will happen.

Parameters:

key - the key of which value list the value will be removed from

value - the value which will be removed from the value list

get

@Nonnull
public Collection<V> get(@Nonnull
                                  K key)

Returns the value list for the given key.

If the key is completely unknown, an empty list will be returned.

Parameters:

key - the key which value list is to be returned

Returns:

the value map associated with the given key or an empty list is the key is unknown

keySet

@Nonnull
public Set<K> keySet()

Returns the set of known keys.

Returns:

returns the set of known keys, that is keys for which put was called

getUnderlyingMap

@Nonnull
public Map<K,Collection<V>> getUnderlyingMap()

Provides direct access to the underlying map.

For the sake of simplicity and extensibility, the original map is returned. Therefore manipulations should be well considered.

Returns:

the underlying Map of this instance.

values

@Nonnull
public List<V> values()

Returns a list of all values for all keys.

Note that this list has no Set like behaviour. Therefore the same value might occur several times if it was added more than once for the same or for different keys.

Returns:

a list of all values stored for all keys

clear

public void clear()

Removes all entries from this map

toString

public String toString()

Overrides:

toString in class Object

merge

public MultiMap<K,V> merge(MultiMap<K,V> other)

Merges the given multi map into this one.

If both maps contain values for the same key, to lists will be joined together.

Note: This will modify the callee instead of creating a new result map

Parameters:

other - the other map to merge into this one

Returns:

the callee itself for further processing

groupingBy

public static <K,V> Collector<V,MultiMap<K,V>,MultiMap<K,V>> groupingBy(Supplier<MultiMap<K,V>> supplier,
                                                                        Function<V,K> classifier)

Creates a Collector which can be used to group a stream into a multi map.

Type Parameters:

K - the extracted key type of the map

V - the value type of the incoming stream and outgoing map

Parameters:

supplier - the factory for creating the result map

classifier - the method used to extract the key from the elements

Returns:

a Collector to be used with Stream.collect(java.util.stream.Collector)

groupingByMultiple

public static <K,V> Collector<V,MultiMap<K,V>,MultiMap<K,V>> groupingByMultiple(Supplier<MultiMap<K,V>> supplier,
                                                                                Function<V,Collection<K>> classifier)

Creates a Collector which can be used to group a stream into a multi map.

This method permits the classifier function to return multiple keys for a single element. The element will be added for all returned keys.

Type Parameters:

K - the extracted key type of the map

V - the value type of the incoming stream and outgoing map

Parameters:

supplier - the factory for creating the result map

classifier - the method used to extract the keys from the elements

Returns:

a Collector to be used with Stream.collect(java.util.stream.Collector)

stream

public Stream<Map.Entry<K,Collection<V>>> stream()

Boilerplate method to access all entries of this map as Stream.

Note: Calling Tuple.flatten(java.util.Map.Entry) via Stream.flatMap(java.util.function.Function) will transform the resulting stream into a stream of all pairs represented by this map.

Returns:

a Stream containing all entries of this map