La fusion des deux Map<String, Integer> avec Java 8 Flux API

@Test
public void test14() throws Exception {
    Map<String, Integer> m1 = ImmutableMap.of("a", 2, "b", 3);
    Map<String, Integer> m2 = ImmutableMap.of("a", 3, "c", 4);

    Map<String, Integer> mx = Stream.of(m1, m2)
        .map(Map::entrySet)          //converts each map into an entry set
        .flatMap(Collection::stream) //converts each set into an entry stream, then
                                     //"concatenates" it in place of the original set
        .collect(
            Collectors.toMap(        //collects into a map
                Map.Entry::getKey,   //where each entry is based
                Map.Entry::getValue, //on the entries in the stream
                Integer::max         //such that if a value already exist for
                                     //a given key, the max of the old
                                     //and new value is taken
            )
        )
    ;

    /* Use the following if you want to create the map with parallel streams
    Map<String, Integer> mx = Stream.of(m1, m2)
        .parallel()
        .map(Map::entrySet)          //converts each map into an entry set
        .flatMap(Collection::stream) //converts each set into an entry stream, then
                                     //"concatenates" it in place of the original set
        .collect(
            Collectors.toConcurrentMap(        //collects into a map
                Map.Entry::getKey,   //where each entry is based
                Map.Entry::getValue, //on the entries in the stream
                Integer::max         //such that if a value already exist for
                                     //a given key, the max of the old
                                     //and new value is taken
            )
        )
    ;
    */

    Map<String, Integer> expected = ImmutableMap.of("a", 3, "b", 3, "c", 4);
    assertEquals(expected, mx);
}

mx = list.stream().collect(HashMap::new,
        (a, b) -> b.forEach((k, v) -> a.merge(k, v, Integer::max)),
        Map::putAll);

Ce couvre le cas général, quelle que soit la taille de la liste et devrait fonctionner avec tous les types, il vous suffit de changer la Integer::max et/ou HashMap::new comme souhaité.

Si vous n'avez pas de soins dont la valeur vient de sortir dans un processus de fusion, il y a beaucoup plus propre solution:

mx = list.stream().collect(HashMap::new, Map::putAll, Map::putAll);

Et méthodes génériques:

public static <K, V> Map<K, V> mergeMaps(Stream<? extends Map<K, V>> stream) {
    return stream.collect(HashMap::new, Map::putAll, Map::putAll);
}

public static <K, V, M extends Map<K, V>> M mergeMaps(Stream<? extends Map<K, V>> stream,
        BinaryOperator<V> mergeFunction, Supplier<M> mapSupplier) {
    return stream.collect(mapSupplier,
            (a, b) -> b.forEach((k, v) -> a.merge(k, v, mergeFunction)),
            Map::putAll);
}

J'ai ajouté ma contribution à la proton pack bibliothèque qui contient les méthodes de l'utilitaire pour le Flux de données de l'API. Voici comment vous pouvez obtenir ce que vous voulez:

Map<String, Integer> mx = MapStream.ofMaps(m1, m2).mergeKeys(Integer::max).collect();

Fondamentalement mergeKeys permettra de recueillir les paires clé-valeur dans une nouvelle carte (en fournissant une fonction de fusion est facultatif, vous vous retrouverez avec un Map<String, List<Integer>> autrement) et le rappel stream() sur le entrySet() pour obtenir une nouvelle MapStream. Ensuite, utilisez collect() pour obtenir la carte.