Java 8 Stream API - 将 Java 9 Collectors.flatMapping 重写为 Java 8

Question

自从Java 9推出了Collectors.flatMapping这个新特性，它在分组或分区的下游起到了作用。例如（摘自这里）：

List<List<Integer>> list = Arrays.asList(
    Arrays.asList(1, 2, 3, 4, 5, 6), 
    Arrays.asList(7, 8, 9, 10));

Map<Integer, List<Integer>> map =list.stream()
    .collect(Collectors.groupingBy(
         Collection::size,
         Collectors.flatMapping(
             l -> l.stream().filter(i -> i % 2 == 0),
             Collectors.toList())));

{4=[8, 10], 6=[2, 4, 6]}

这是一种相当优雅的方法，只使用了3个收集器。我需要在java-8中重写收集器，因为它还不支持。我的尝试使用了6个收集器，这是相当广泛的使用，我无法想出一种使用更少收集器的方法：

Map<Integer, List<Integer>> map = list.stream()
    .collect(Collectors.groupingBy(
        Collection::size,
        Collectors.collectingAndThen(
            Collectors.mapping(
                l -> l.stream().filter(i -> i % 2 == 0).collect(Collectors.toList()),
                Collectors.toList()),
            i -> i.stream().flatMap(j -> j.stream()).collect(Collectors.toList()))));

是否有一种更好的方法，仅使用java-8？

- Nikolas Charalambidis

---

“@Michael同意了，你应该发布一个这个后移版本，我很高兴投票支持。我认为Holger已经有一个了，但我在stackoverflow上找不到它......” - Eugene

找到了... - Eugene

Answer 1

我只需要回溯实现flatMapping。它仅需要2个方法和1个类，没有其他依赖项。

此外，当升级到Java 9时，您可以将其版本标记为弃用，并使用正确的版本替换任何使用它的地方。 下面的代码来自JDK。我没有编写它。我已经使用您的示例测试过它并返回了相同的结果。

class Nikollectors
{
   public static <T, U, A, R> Collector<T, ?, R> flatMapping(Function<? super T, ? extends Stream<? extends U>> mapper, Collector<? super U, A, R> downstream) {
        BiConsumer<A, ? super U> downstreamAccumulator = downstream.accumulator();
        return new CollectorImpl<>(downstream.supplier(),
            (r, t) -> {
                try (Stream<? extends U> result = mapper.apply(t)) {
                    if (result != null)
                        result.sequential().forEach(u -> downstreamAccumulator.accept(r, u));
                }
            },
            downstream.combiner(), downstream.finisher(),
            downstream.characteristics());
    }

   private static class CollectorImpl<T, A, R> implements Collector<T, A, R>
   {
        private final Supplier<A> supplier;
        private final BiConsumer<A, T> accumulator;
        private final BinaryOperator<A> combiner;
        private final Function<A, R> finisher;
        private final Set<Characteristics> characteristics;

        CollectorImpl(Supplier<A> supplier,
                      BiConsumer<A, T> accumulator,
                      BinaryOperator<A> combiner,
                      Function<A,R> finisher,
                      Set<Characteristics> characteristics) {
            this.supplier = supplier;
            this.accumulator = accumulator;
            this.combiner = combiner;
            this.finisher = finisher;
            this.characteristics = characteristics;
        }

        CollectorImpl(Supplier<A> supplier,
                      BiConsumer<A, T> accumulator,
                      BinaryOperator<A> combiner,
                      Set<Characteristics> characteristics) {
            this(supplier, accumulator, combiner, castingIdentity(), characteristics);
        }

        @Override
        public BiConsumer<A, T> accumulator() {
            return accumulator;
        }

        @Override
        public Supplier<A> supplier() {
            return supplier;
        }

        @Override
        public BinaryOperator<A> combiner() {
            return combiner;
        }

        @Override
        public Function<A, R> finisher() {
            return finisher;
        }

        @Override
        public Set<Characteristics> characteristics() {
            return characteristics;
        }
    }

   private static <I, R> Function<I, R> castingIdentity() {
       return i -> (R) i;
   }
}

使用示例：

Map<Integer, List<Integer>> map =list.stream()
    .collect(Collectors.groupingBy(
         Collection::size,
         Nikollectors.flatMapping( // <<<
             l -> l.stream().filter(i -> i % 2 == 0),
             Collectors.toList()
        )
    )
);

- Michael

---

你应该为 Nikollectors 得到两个赞，同时还可以添加一个使用示例和一个静态工厂方法来返回 Collectors::flatMapping，以形成一个完整的示例。 - Eugene

你可能在开玩笑，但是在我的项目中我们有一个名为 xxx.HolgerUtil 的包，只是为了确保它来自哪里，不是开玩笑的。 :) - Eugene

我被卡在Java 8上了，这就是我没有意识到自己正在寻找的答案。谢谢！ - moraleboost

Answer 2

对于仅限于此特定情况，我想这将是一个更简单的版本：

Map<Integer, List<Integer>> map =
        list.stream()
            .collect(Collectors.toMap(
                Collection::size,
                x -> x.stream().filter(y -> y % 2 == 0).collect(Collectors.toList())
            ));

如果涉及合并（两个大小相同的集合），我将添加一个非常简单的merge函数：

 Map<Integer, List<Integer>> map =
        list.stream()
            .collect(Collectors.toMap(
                Collection::size,
                x -> x.stream().filter(y -> y % 2 == 0).collect(Collectors.toCollection(ArrayList::new)),
                (left, right) -> {
                    left.addAll(right);
                    return left;
                }
            ));

否则，我同意Michael在该评论中的观点，这并不难以回溯到Java 8。

- Eugene