Lambda Java8 stream.map在同一个流上输出不同的映射函数？

有人能帮我优化下面的代码吗。我不想在同一个列表上流3次。我必须在同一个列表上迭代并应用不同的映射函数。 有人能提出更好的解决方案吗

List<Dummy> dummy = getDummyData(); //Assume we are getting data from some source
List<NewDummy> newDummyList = dummy.stream().map(eachDummy -> mapper.map(eachDummy, NewDummy.class)).collect(Collectors.toList());

if(someCondition) {
  final BigDecimal amount1 = dummy.stream().filter(eachDummy -> Optional.ofNullable(eachDummy.getAmount1()).isPresent())
                                  .map(Dummy::getAmount1).reduce(BigDecimal.ZERO, BigDecimal::add);
  final BigDecimal amount2 = dummy.stream().filter(eachDummy -> Optional.ofNullable(eachDummy.getAmount2()).isPresent())
                                  .map(Dummy::getAmount2).reduce(BigDecimal.ZERO, BigDecimal::add);

  return new DummyObject(newDummyList, amount1, amount2);
} else {
    return new DummyObject(newDummyList);
}

List dummy=getDummyData（）//假设我们从某个来源获取数据
List newDummyList=dummy.stream（）.map（eachDummy->mapper.map（eachDummy，NewDummy.class））.collect（Collectors.toList（））；
如果（某些条件）{
final BigDecimal amount1=dummy.stream（）.filter（eachDummy->Optional.ofNullable（eachDummy.getAmount1（））.isPresent（））
.map（Dummy:：getAmount1）.reduce（BigDecimal.ZERO，BigDecimal:：add）；
final BigDecimal amount2=dummy.stream（）.filter（eachDummy->Optional.ofNullable（eachDummy.getAmount2（））.isPresent（））
.map（Dummy:：getAmount2）.reduce（BigDecimal.ZERO，BigDecimal:：add）；
返回新的DummyObject（newDummyList，数量1，数量2）；
}否则{
返回新的DummyObject（newDummyList）；
}

这似乎是定制收集器的理想用例。但在此之前，我认为您可以将金额的总和简化如下：

BigDecimal amount1 = dummy.stream()
    .map(Dummy::getAmount1)
    .filter(Objects::nonNull)
    .reduce(BigDecimal::add).orElse(BigDecimal.ZERO);

现在，自定义收集器。您可以将

Dummy

的实例累积到静态实用程序方法内专用本地类的实例中：

static Collector<Dummy, ?, DummyObject> toDummyObject(
        Function<Dummy, NewDummy> mapper, 
        boolean someCondition) {

    class Accumulator {
        List<NewDummy> newDummyList = new ArrayList<>();
        BigDecimal amount1 = BigDecimal.ZERO;
        BigDecimal amount2 = BigDecimal.ZERO;

        public void add(Dummy dummy) {
            newDummyList.add(mapper.apply(dummy));
        }

        public void addAndSum(Dummy dummy) {
            if (dummy.getAmount1() != null) amount1 = amount1.add(dummy.getAmount1());
            if (dummy.getAmount2() != null) amount2 = amount2.add(dummy.getAmount2());
            add(dummy);
        }

        public Accumulator merge(Accumulator another) {
            newDummyList.addAll(another.newDummyList);
            return this;
        }

        public Accumulator mergeAndSum(Accumulator another) {
            amount1 = amount1.add(another.amount1);
            amount2 = amount2.add(another.amount2);
            return merge(another);
        }

        public DummyObject finish() {
            return someCondition ?
                new DummyObject(newDummyList, amount1, amount2) :
                new DummyObject(newDummyList);
        }
    }

    return Collector.of(
        Accumulator::new, 
        someCondition ? Accumulator::addAndSum : Accumulator::add,
        someCondition ? Accumulator::mergeAndSum : Accumulator::merge,
        Accumulator::finish);
}

我同意

收集器
似乎是这里最好的选择

但是，我不想实现一个非常专门的
收集器
，我更喜欢只实现一些通用的“构建块”，然后使用这些块来组成我在给定情况下需要的
收集器

假设：

interface Mapper<T> {
    T map(Dummy dummy, Class<T> type);
}


下面是我如何编写特定于用例的
收集器
s：

private static Collector<Dummy, ?, DummyObject> toDummyObjectWithoutSums(Mapper<NewDummy> mapper) {
    return Collectors.collectingAndThen(toNewDummyList(mapper), DummyObject::new);
}

private static Collector<Dummy, ?, List<NewDummy>> toNewDummyList(Mapper<NewDummy> mapper) {
    return Collectors.mapping(dummy -> mapper.map(dummy, NewDummy.class), Collectors.toList());
}

private static Collector<Dummy, ?, DummyObject> toDummyObjectWithSums(Mapper<NewDummy> mapper) {
    return ExtraCollectors.collectingBoth(
            toNewDummyList(mapper),
            sumGroupCollector(),
            (newDummyList, amountSumPair) -> new DummyObject(
                    newDummyList, amountSumPair.getAmountSum1(), amountSumPair.getAmountSum2()
            )
    );
}

private static Collector<Dummy, ?, AmountSumPair> sumGroupCollector() {
    return ExtraCollectors.collectingBoth(
            summingAmount(Dummy::getAmount1),
            summingAmount(Dummy::getAmount2),
            AmountSumPair::new
    );
}

static Collector<Dummy, ?, BigDecimal> summingAmount(Function<Dummy, BigDecimal> getter) {
    return Collectors.mapping(getter,
            ExtraCollectors.filtering(Objects::nonNull,
                    ExtraCollectors.summingBigDecimal()
            )
    );
}

private static class AmountSumPair {
    private final BigDecimal amountSum1;
    private final BigDecimal amountSum2;

    // constructor + getters
}

下面是
BiCollectorHandler
类（由
extracollector内部使用。同时收集两个
）：

final类BiCollectorHandler{
私人最终收藏家1；
私人最终收藏家2；
双收集器处理程序（收集器收集器1、收集器收集器2）{
this.collector1=collector1；
this.collector2=collector2；
}
双累加器（双累加器）{
返回新的BiAccumulator（collector1.supplier（）.get（），collector2.supplier（）.get（））；
}
末级双累加器{
最终A1 acc1；
最终A2 acc2；
专用双累加器（A1 acc1、A2 acc2）{
this.acc1=acc1；
this.acc2=acc2；
}
无效接受（T）{
收集器1.累加器（）.接受（acc1，t）；
收集器2.累加器（）.接受（acc2，t）；
}
双累加器联合收割机（双累加器其他）{
A1 combined1=collector1.combiner（）.apply（acc1，other.acc1）；
A2 combined2=collector2.combiner（）.apply（acc2，other.acc2）；
返回新的双累加器（combined1，combined2）；
}
R表面处理（双功能双整理器）{
R1结果1=collector1.finisher（）.apply（acc1）；
R2结果2=collector2.finisher（）.apply（acc2）；
返回biFinisher.apply（结果1、结果2）；
}
}
}
您的
eachDummy:：getAmount1
和
eachDummy:：getAmount2
应该分别是
Dummy:：getAmount1
和
Dummy:：getAmount1
。@TomaszLinkowski yes..这是正确的。。意志update@federico谢谢你提出了一个很好的选择。就性能而言，您不认为在原始方法中使用Reduce来计算和的性能会优于您在这里建议的代码吗。基本上，如果我想比较你建议的方法和讨论中的方法，我应该怎么做？@prats谢谢你的话。在这里搜索jmh microbenchmark，您会发现非常有用的信息。我相信（理论上）我的版本会比你的稍好一点，只是一点点。两个版本具有相同的时间复杂性。我认为有3个单独的循环或流是可以的，也许你可以重构一个私有方法。调试代码后，我意识到组合器（mergeAndSum或merge）将永远不会被调用，因为这是一个顺序流。因此，我们可以将其更改为并行流以利用combiners@prats您可以尝试并测量，但我怀疑您是否会发现这项工作有任何改进+1（我打赌它花费了相当长的时间编写），顺便说一句，
BiCollector
可能会出现在jdk-12上。@Eugene Ha，在我之前；）很高兴知道，谢谢你的信息！我希望这个特性能够应用到JDK12上。是的，写起来花了一段时间——比我预期的要长一点，但这就是SO的问题：解决像这里这样的问题一旦开始就会上瘾；）Tomasz，这是一项伟大的工作，我同意拥有这些构建块是一种更好的方法。我也非常喜欢你最初的回答，我认为它显示了硬币的另一面，也就是说，
你不需要专门的收款人，只要将金额的总和重构成一个私人方法，你就可以在列表上流3次。
@federicoperataschaffner谢谢！）关于我最初的回答：这实际上是错误的，因为我误解了这个问题，只流了一次
List
，流了两次
List
。当然，
列表
的三重流也可能是一个选项，但由于OP写了“假设我们从某个源获取数据”，我认为这样的流被认为是昂贵的。更新：“BiCollector”功能作为
收集器出现在JDK12上。teeing
：。
Collector<Dummy, ?, DummyObject> dummyObjectCollector = someCondition
        ? toDummyObjectWithSums(mapper)
        : toDummyObjectWithoutSums(mapper);
return dummy.stream().collect(dummyObjectCollector);

private static Collector<Dummy, ?, DummyObject> toDummyObjectWithoutSums(Mapper<NewDummy> mapper) {
    return Collectors.collectingAndThen(toNewDummyList(mapper), DummyObject::new);
}

private static Collector<Dummy, ?, List<NewDummy>> toNewDummyList(Mapper<NewDummy> mapper) {
    return Collectors.mapping(dummy -> mapper.map(dummy, NewDummy.class), Collectors.toList());
}

private static Collector<Dummy, ?, DummyObject> toDummyObjectWithSums(Mapper<NewDummy> mapper) {
    return ExtraCollectors.collectingBoth(
            toNewDummyList(mapper),
            sumGroupCollector(),
            (newDummyList, amountSumPair) -> new DummyObject(
                    newDummyList, amountSumPair.getAmountSum1(), amountSumPair.getAmountSum2()
            )
    );
}

private static Collector<Dummy, ?, AmountSumPair> sumGroupCollector() {
    return ExtraCollectors.collectingBoth(
            summingAmount(Dummy::getAmount1),
            summingAmount(Dummy::getAmount2),
            AmountSumPair::new
    );
}

static Collector<Dummy, ?, BigDecimal> summingAmount(Function<Dummy, BigDecimal> getter) {
    return Collectors.mapping(getter,
            ExtraCollectors.filtering(Objects::nonNull,
                    ExtraCollectors.summingBigDecimal()
            )
    );
}

private static class AmountSumPair {
    private final BigDecimal amountSum1;
    private final BigDecimal amountSum2;

    // constructor + getters
}

final class ExtraCollectors {

    static Collector<BigDecimal, ?, BigDecimal> summingBigDecimal() {
        return Collectors.reducing(BigDecimal.ZERO, BigDecimal::add);
    }

    static <T, A, R> Collector<T, A, R> filtering(
            Predicate<T> filter, Collector<T, A, R> downstream) {
        return Collector.of(
                downstream.supplier(),
                (A acc, T t) -> {
                    if (filter.test(t)) {
                        downstream.accumulator().accept(acc, t);
                    }
                },
                downstream.combiner(),
                downstream.finisher(),
                downstream.characteristics().toArray(new Collector.Characteristics[0])
        );
    }

    static <T, R1, R2, R> Collector<T, ?, R> collectingBoth(
            Collector<T, ?, R1> collector1, Collector<T, ?, R2> collector2, BiFunction<R1, R2, R> biFinisher) {
        return collectingBoth(new BiCollectorHandler<>(collector1, collector2), biFinisher);
    }

    // method needed to capture A1 and A2
    private static <T, A1, R1, A2, R2, R> Collector<T, ?, R> collectingBoth(
            BiCollectorHandler<T, A1, R1, A2, R2> biCollectorHandler, BiFunction<R1, R2, R> biFinisher) {
        return Collector.<T, BiCollectorHandler<T, A1, R1, A2, R2>.BiAccumulator, R>of(
                biCollectorHandler::newBiAccumulator,
                BiCollectorHandler.BiAccumulator::accept,
                BiCollectorHandler.BiAccumulator::combine,
                biAccumulator -> biAccumulator.finish(biFinisher)
        );
    }
}

final class BiCollectorHandler<T, A1, R1, A2, R2> {

    private final Collector<T, A1, R1> collector1;
    private final Collector<T, A2, R2> collector2;

    BiCollectorHandler(Collector<T, A1, R1> collector1, Collector<T, A2, R2> collector2) {
        this.collector1 = collector1;
        this.collector2 = collector2;
    }

    BiAccumulator newBiAccumulator() {
        return new BiAccumulator(collector1.supplier().get(), collector2.supplier().get());
    }

    final class BiAccumulator {

        final A1 acc1;
        final A2 acc2;

        private BiAccumulator(A1 acc1, A2 acc2) {
            this.acc1 = acc1;
            this.acc2 = acc2;
        }

        void accept(T t) {
            collector1.accumulator().accept(acc1, t);
            collector2.accumulator().accept(acc2, t);
        }

        BiAccumulator combine(BiAccumulator other) {
            A1 combined1 = collector1.combiner().apply(acc1, other.acc1);
            A2 combined2 = collector2.combiner().apply(acc2, other.acc2);
            return new BiAccumulator(combined1, combined2);
        }

        <R> R finish(BiFunction<R1, R2, R> biFinisher) {
            R1 result1 = collector1.finisher().apply(acc1);
            R2 result2 = collector2.finisher().apply(acc2);
            return biFinisher.apply(result1, result2);
        }
    }
}