Is there an elegant way to reduce a stream of maps to one map

Question

Given some maps, is there a one-line way to put all their entries into one map?

Ignoring issues of nulls, over-writing entries etc, what I would like to code is:

public static <K, V> Map<K, V> reduce(Map<K, V>... maps) {
    return Arrays.stream(maps)
        .reduce(new HashMap<K, V>(), (a, b) -> a.putAll(b));
}

but this gives a compile error, because a.putAll(b) is void. If it returned this, it would work.

To work around this, I coded:

public static <K, V> Map<K, V> reduce(Map<K, V>... maps) {
    return Arrays.stream(maps)
        .reduce(new HashMap<K, V>(), (a, b) -> {a.putAll(b); return a;});
}

which compiles and works, but it's an ugly lambda; coding return a; feels redundant.

One approach is to refactor out a utility method:

public static <K, V> Map<K, V> reduce(Map<K, V> a, Map<K, V> b) {
    a.putAll(b);
    return a;
}

which cleans up the lambda:

public static <K, V> Map<K, V> reduce(Map<K, V>... maps) {
    return Arrays.stream(maps)
       .reduce(new HashMap<K, V>(), (a, b) -> reduce(a, b));
}

but now I have a, albeit reusable, somewhat useless utility method.

Is there a more elegant way to call a method on the accumulator and return it within a lambda?

Answer 1

reduce works similarly to

U result = identity;
for (T element : this stream)
    result = accumulator.apply(result, element)
return result;

which means that the lambda representing accumulator.apply needs to return result (final or intermediate one).

If you want to avoid this behaviour use collect which works more like

R result = supplier.get();
for (T element : this stream)
    accumulator.accept(result, element);
return result;

so lambda representing accumulator.accept don't need to return any value but to modify result based on element.

Example:

public static <K, V> Map<K, V> reduce(Map<K, V>... maps) {
    return Arrays.stream(maps)
            .collect(HashMap::new, Map::putAll, Map::putAll);
            //                          ^            ^
            //                          |         collect results from parallel streams
            //                       collect results in single thread
}