Returns a Collector that accumulates elements into a
Map whose keys and values are the result of applying the provided
mapping functions to the input elements.
If the mapped
keys contain duplicates (according to Object.equals(Object)),
the value mapping function is applied to each equal element, and the
results are merged using the provided merging function.
There are no guarantees on the type, mutability, serializability,
or thread-safety of the Map returned.
<T> | the type of the input elements | |
<K> | the output type of the key mapping function | |
<U> | the output type of the value mapping function | |
keyMapper | a mapping function to produce keys | |
valueMapper | a mapping function to produce values | |
mergeFunction | a merge function, used to resolve collisions between
values associated with the same key, as supplied
to Map.merge(Object, Object, BiFunction) |
Collector which collects elements into a Map
whose keys are the result of applying a key mapping function to the input
elements, and whose values are the result of applying a value mapping
function to all input elements equal to the key and combining them
using the merge function
toMap(Function, Function), toMap(Function, Function, BinaryOperator, Supplier), toConcurrentMap(Function, Function, BinaryOperator)
@apiNote
There are multiple ways to deal with collisions between multiple elements
mapping to the same key. The other forms of toMap simply use
a merge function that throws unconditionally, but you can easily write
more flexible merge policies. For example, if you have a stream
of Person, and you want to produce a "phone book" mapping name to
address, but it is possible that two persons have the same name, you can
do as follows to gracefully deal with these collisions, and produce a
Map mapping names to a concatenated list of addresses:
Map<String, String> phoneBook
= people.stream().collect(
toMap(Person::getName,
Person::getAddress,
(s, a) -> s + ", " + a));
Collector is not concurrent. For parallel stream
pipelines, the combiner function operates by merging the keys
from one map into another, which can be an expensive operation. If it is
not required that results are merged into the Map in encounter
order, using toConcurrentMap(Function, Function, BinaryOperator)
may offer better parallel performance.
Diagram: Collectors