Returns a concurrent Collector that accumulates elements into a
ConcurrentMap whose keys and values are the result of applying
the provided mapping functions to the input elements.
If the mapped keys contains 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.
<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
ConcurrentMap 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
toConcurrentMap(Function, Function), toConcurrentMap(Function, Function, BinaryOperator, Supplier), toMap(Function, Function, BinaryOperator)
@apiNote
There are multiple ways to deal with collisions between multiple elements
mapping to the same key. The other forms of toConcurrentMap 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 deals with these collisions, and produce a
Map mapping names to a concatenated list of addresses:
Map<String, String> phoneBook
people.stream().collect(toConcurrentMap(Person::getName,
Person::getAddress,
(s, a) -> s + ", " + a));
This is a concurrent and
unordered Collector.
Diagram: Collectors