使用reduce和collect查找平均值

Question

我试图理解新的Java8流API。

http://docs.oracle.com/javase/tutorial/collections/streams/reduction.html

我找到了使用collect API查找数字平均值的示例。但我觉得，使用reduce（）也可以做到这一点。

public class Test {

    public static void main(String[] args) {
        // Using collect
        System.out.println(Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
            .collect(Averager::new, Averager::accept, Averager::combine)
            .average());

        // Using reduce
        System.out.println(Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
            .reduce(new Averager(), (t, u) -> {
                t.accept(u);
                return t;
            }, (t, u) -> {
                t.combine(u);
                return t;
            }).average());
    }

    private static class Averager {
        private int total = 0;
        private int count = 0;

        public Averager() {
            // System.out.println("Creating averager");
        }

        public double average() {
            // System.out.println("Finding average");
            return count > 0 ? ((double) total) / count : 0;
        }

        public void accept(int i) {
            // System.out.println("Accepting " + i);
            total += i;
            count++;
        }

        public void combine(Averager other) {
            // System.out.println("Combining the averager : " + other);
            total += other.total;
            count += other.count;
        }

        @Override
        public String toString() {
            return "[total : " + total + ", count: " + count + "]";
        }
    }
}

Answer 1

reduce和collection之间的区别在于，collection是一种增强的约简形式，可以并行处理可变对象。collection算法对各种结果对象进行线程限制，这样即使它们不是线程安全的，也可以安全地进行更改。这就是averager使用collection工作的原因。对于使用reduce的顺序计算，这通常并不重要，但是对于并行计算，它将给出错误的结果，正如您所观察到的。

关键的一点是，reduce只要处理的是值，而不是可变对象，它就可以工作。您可以通过查看reduce的第一个参数来了解这一点。示例代码传递new Averager()，这是一个单个对象，在并行约简中多个线程将其用作标识值。并行流的工作方式是将工作负载拆分为由单个线程处理的段。如果多个线程正在突变同一个（非线程安全的）对象，那么应该清楚为什么这会导致不正确的结果。

可以使用reduce来计算平均值，但您需要使累加对象是不可变的。考虑对象immutableaverager:

static class ImmutableAverager {
    private final int total;
    private final int count;

    public ImmutableAverager() {
        this.total = 0;
        this.count = 0;
    }
    
    public ImmutableAverager(int total, int count) {
        this.total = total;
        this.count = count;
    }

    public double average() {
        return count > 0 ? ((double) total) / count : 0;
    }

    public ImmutableAverager accept(int i) {
        return new ImmutableAverager(total + i, count + 1);
    }

    public ImmutableAverager combine(ImmutableAverager other) {
        return new ImmutableAverager(total + other.total, count + other.count);
    }
}

注意，我调整了accept和combine的签名，以返回一个新的immutableaverager而不是更改this。（这些更改还使方法与reduce的函数参数相匹配，因此我们可以使用方法引用。）您可以使用immutableaverager，如下所示：

    double average = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
            .parallel()
            .reduce(new ImmutableAverager(), 
                    ImmutableAverager::accept,
                    ImmutableAverager::combine)
            .average();
    System.out.println("Average: "+average);

与reduce一起使用不可变值对象应该会并行地给出正确的结果。

最后，请注意，IntStream和DoubleStream具有SummaryStatistics()方法，而Collectors具有AveragingDouble、AveragingInt和AveragingLong方法可以为您执行这些计算。然而，我认为问题更多的是关于收集和减少的机制，而不是关于如何最简洁地做平均。