下游收集器的 partitioningBy 产生了意想不到的结果

Question

我有一个测试程序：

public class App {

    public static void main(String[] args) {

        List<Integer> a = Arrays.asList(1, 11);
        List<Integer> b = Arrays.asList(2, 22);
        List<Integer> c = Arrays.asList(3, 33);

        Map<String, List<Integer>> map = new HashMap<>();
        map.put("a", a);
        map.put("b", b);
        map.put("c", c);

        Set<String> valid = new HashSet<>();
        valid.add("a");

        Map<Boolean, List<Map.Entry<String, List<Integer>>>> partitions =
            map.entrySet().stream()
                .collect(Collectors.partitioningBy(
                    entry -> valid.contains(entry.getKey())));

        System.out.println(partitions);

        // partition by the key of the map
        // then reduce the values into a single collection

        Map<Boolean, List<Integer>> result = map.entrySet().stream()
            .collect(Collectors.partitioningBy(
                entry -> valid.contains(entry.getKey()),
                Collectors.mapping(Map.Entry::getValue,
                                   Collectors.reducing(new ArrayList<>(),
                                                       (l1, l2) -> {
                                                           l1.addAll(l2);
                                                           return l1;
                                                       }))));

        System.out.println(result);
    }
}

我希望最终结果是

{false=[b=[2, 22], c=[3, 33]], true=[a=[1, 11]]}
{false=[2, 22, 3, 33], true=[1, 11]}

但在实际结果中，true 和 false 键都具有全部 6 个整数：

{false=[b=[2, 22], c=[3, 33]], true=[a=[1, 11]]}
{false=[1, 11, 2, 22, 3, 33], true=[1, 11, 2, 22, 3, 33]}

注意这两个分区函数是完全一样的。但是下游混淆了单独分区中的值。怎么可能？我假设下游只会在每个分区上运行...

我错过了什么？

谢谢。

Answer 1

为了减少在两个分区中使用相同的 ArrayList 引用。您可以使用 Collectors.toMap 并创建一个合并两个列表的新实例。

Map<Boolean, List<Integer>> result = 
        map.entrySet()
        .stream()
        .collect(Collectors.toMap(e -> valid.contains(e.getKey()), Map.Entry::getValue, 
        (l1, l2) -> {
          List<Integer> l3 = new ArrayList<>(l1);
          l3.addAll(l2);
          return l3;
        }));

如果你想用同样的口味

Map<Boolean, List<Integer>> result = 
        map.entrySet()
        .stream()
        .collect(Collectors.toMap(e-> valid.contains(e.getKey()), Map.Entry::getValue,
            (l1, l2) -> Stream.concat(l1.stream(), l2.stream())
                              .collect(Collectors.toList())));

Answer 2

从 Java 9 开始作为下游收集器完成 , you can use Collectors.groupingBy using your classifier with Collectors.flatMapping。

Map<Boolean, List<Integer>> result = map.entrySet().stream()
    .collect(Collectors.groupingBy(
         e -> valid.contains(e.getKey()), 
         Collectors.flatMapping(e -> e.getValue().stream(), Collectors.toList())));

下游收集器的 partitioningBy 产生了意想不到的结果

partitioningBy with a downstream collector produced an unexpected result

java

functional-programming

java-8

java-stream

collectors