Aleksandr Shitov

Hi,
recommend you to read https://docs.oracle.com/javaee/6/tutorial/doc/bncdq.html

Piet Souris wrote:Hmmm, I start to belive that Alex Shitov is right, after all. My above code does not work; I added a third Map, and the reducing reduced the complete value Collection of all Maps, no matter what key it was.
Does anyone know what I am doing wrong?
public class JavaRanch16 {    /**     * @param args the command line arguments     */    public static void main(String[] args) {        var map1 = Map.of("a", List.of(1, 2, 3));        var map2 = Map.of("a", List.of(2, 3, 4));        var map3 = Map.of("a", List.of(3, 4, 5), "b", List.of(10));        var mapTotal = List.of(map1, map2, map3);        Map<String, List<Integer>> result = compressMap2(mapTotal);        System.out.println("****** the final map, incorrect ************");        result.entrySet().forEach(System.out::println);    }        public static <T, S> Map<T, List<S>> compressMap2(List<Map<T, List<S>>> maps) {        List<Entry<T, List<S>>> temp = maps.stream().collect(            () -> new ArrayList<>(),            (list, map) -> list.addAll(map.entrySet()),            (list1, list2) -> list1.addAll(list2)        );        System.out.println("******** The combined listt of the entries************");        temp.forEach(System.out::println);        System.out.println("******************************************************");        Map<T, List<S>> result = temp.stream()            .collect(                groupingBy(                    Entry::getKey,                    mapping(                        Entry::getValue,                        Collectors.reducing(                            new ArrayList<>(),                            (list1, list2) -> {list1.addAll(list2); return list1;}                        )                    )                )            )            ;        return result;    } }
Output:

******** The combined listt of the entries************
a=[1, 2, 3]
a=[2, 3, 4]
b=[10]
a=[3, 4, 5]
******************************************************
****** the final map, incorrect ************
a=[1, 2, 3, 2, 3, 4, 10, 3, 4, 5]
b=[1, 2, 3, 2, 3, 4, 10, 3, 4, 5]

This is because ArrayList in Collectors.reducing(new ArrayList<>(), ...) is created only once and used for each grouped key as initial(zero-size) list. Fixed version of compressMap2(...):

   public static <T, S> Map<T, List<S>> compressMap2(List<Map<T, List<S>>> maps) {        List<Map.Entry<T, List<S>>> temp = maps.stream().collect(                () -> new ArrayList<>(),                (list, map) -> list.addAll(map.entrySet()),                (list1, list2) -> list1.addAll(list2)        );        System.out.println("******** The combined listt of the entries************");        temp.forEach(System.out::println);        System.out.println("******************************************************");        Map<T, List<S>> result = temp.stream()                .collect(                        Collectors.groupingBy(                                Map.Entry::getKey,                                mapping(                                        Map.Entry::getValue,                                        Collectors.reducing(                                                new ArrayList<>(), //this list is used as initial list for each grouping key, Collections.emptyList() could be used instead                                                (list1, list2) -> {                                                    List<S> combined = new ArrayList<>(list1); //it is not memory efficient, only to show how to fix it                                                    combined.addAll(list2);                                                    return combined;                                                }                                        )                                )                        )                );        return result;    }

Thanks for evaluation)

Stephan van Hulst wrote:Welcome to CodeRanch Alex!

You can probably simplify your collection step with a groupingBy(), rather than a toMap().

Won't be work unfortunately, because there is no appropriate mapper for groupingBy function to flat grouped lists to one.

What do you think about that?
   public static Map<String, List<Integer>> merge(List<Map<String, List<Integer>>> maps) {        return maps.stream()                .flatMap(map -> map.entrySet().stream())                .collect(Collectors.toMap(                        Map.Entry::getKey,                        Map.Entry::getValue,                        (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList())));    }