Lambda的Reduce

简介

Stream API提供了丰富的intermediate（filter、sorted、distinct、map…）、reduction 和terminal函数，这些函数同样支持并行执行。
其中reduction可对一个元素流进行计算、合并来得到一个最终结果

关键概念

• 初始值Identity：reduce操作的初始值
• 累加器Accumulator：带有两个参数的函数，一个为reduce操作的部分结果，另一个为流中下一个要参与计算的函数
• 合并器Combiner：用于合并reduce操作部分结果的函数，用于两个场景：1.并行计算的算子 2.当累加器参数类型与累加器实现类型不匹配时，用来定义结果类型
  

reduce的几个函数

abstract class ReferencePipeline<P_IN, P_OUT>
        extends AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>>
        implements Stream<P_OUT>  {

    @Override
    public final P_OUT reduce(final P_OUT identity, final BinaryOperator<P_OUT> accumulator) {
        return evaluate(ReduceOps.makeRef(identity, accumulator, accumulator));
    }

    @Override
    public final Optional<P_OUT> reduce(BinaryOperator<P_OUT> accumulator) {
        return evaluate(ReduceOps.makeRef(accumulator));
    }

    @Override
    public final <R> R reduce(R identity, BiFunction<R, ? super P_OUT, R> accumulator, BinaryOperator<R> combiner) {
        return evaluate(ReduceOps.makeRef(identity, accumulator, combiner));        
}

case

定义一个有初始值为10的累加器Accumulator

初始值为10，subtotal为每一次计算后的子结果

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        int result = numbers
                .stream()
                .reduce(10, (subtotal, element) -> subtotal + element);
        // 31

为了更好的理解，加上一些输出：

        int result = numbers
                .stream()
                .reduce(10, new BinaryOperator<Integer>() {
                    @Override
                    public Integer apply(Integer subtotal, Integer val) {
                        System.out.println("subtotal : " + subtotal + ", val : " + val);
                        return subtotal + val;
                    }
                });

subtotal : 10, val : 1
subtotal : 11, val : 2
subtotal : 13, val : 3
subtotal : 16, val : 4
subtotal : 20, val : 5
subtotal : 25, val : 6

合并器Combiner

上文说到Combiner用于两个场景：1.并行计算的算子 2.当累加器参数类型与累加器实现类型不匹配时，用来定义结果类型

定义结果类型

假设我们有一个User类，User有name和age，我们想累加计算所有的User实体算出总年龄

 List<User> users = Arrays.asList(new User("cqr1", 1), new User("cqr2", 2), new User("cqr3",4),
        new User("cqr4", 7),new User("cqr5", 10),new User("cqr6", 12)
        );

int result1 = users.stream().reduce(2, new BinaryOperator<Integer>() {
                    @Override
                    public Integer apply(Integer integer1, User user) {
                        return integer1 + user.getAge();
                    }
                });

我们会发现此时编辑器报错，原因是我们操作的是一个User对象流，累加器参数的类型是Integer和User。然而，累加器的实现是整数的和，因此编译器无法推断user参数的类型。
此时合并器的作用就派上用场了，定义Combiner来告诉编译器类型是什么

        int result = users.stream()
                .reduce(2, new BiFunction<Integer, User, Integer>() {
                    @Override
                    public Integer apply(Integer partialAgeResult, User user) {
                        System.out.println("执行了1," + "partialAgeResult : " + partialAgeResult + ", user.getAge : " + user.getAge() );
                        return partialAgeResult + user.getAge();
                    }
                }, new BinaryOperator<Integer>() {
                    @Override
                    public Integer apply(Integer integer1, Integer integer2) {
                        System.out.println("执行了2,  integer1 : " + integer1 + " , integer2 : " + integer2);
                        return integer1 + integer2;
                    }
                });

执行了1,partialAgeResult : 2, user.getAge : 1
执行了1,partialAgeResult : 3, user.getAge : 2
执行了1,partialAgeResult : 5, user.getAge : 4
执行了1,partialAgeResult : 9, user.getAge : 7
执行了1,partialAgeResult : 16, user.getAge : 10
执行了1,partialAgeResult : 26, user.getAge : 12

通用打印的内容可发现，Combiner并没有执行，为什么说它只是来告诉编译器结果类型的？我们可以把Combiner的逻辑修改，发现并没有改变结果

        int result = users.stream()
                .reduce(2, (partialAgeResult, user) -> partialAgeResult + user.getAge(), 
                        (integer1, integer2) -> integer1 - integer2);
    	// 输出38

并行计算的算子

使用parallel要确保：

• 结果不受操作的对象的顺序影响
• 操作不影响数据源（比如mysql）
• 无状态操作，对给定的相同的输入产生相同的输出

reduce是并行执行的，提高了程序运行的效率（适用于大数据量和计算耗时的操作，非此情形使用可能适得其反）

        int result = users.stream().parallel()
                .reduce(2, (partialAgeResult, user) -> {
                    System.out.println("执行了1," + "partialAgeResult : " + partialAgeResult + ", user.getAge : " + user.getAge() );
                    return partialAgeResult + user.getAge();
                }, (integer1, integer2) -> {
                    System.out.println("执行了2,  integer1 : " + integer1 + " , integer2 : " + integer2);
                    return integer1 + integer2;
                });

执行了1,partialAgeResult : 2, user.getAge : 12
执行了1,partialAgeResult : 2, user.getAge : 10
执行了1,partialAgeResult : 2, user.getAge : 7
执行了1,partialAgeResult : 2, user.getAge : 2
执行了1,partialAgeResult : 2, user.getAge : 1
执行了1,partialAgeResult : 2, user.getAge : 4
执行了2,  integer1 : 12 , integer2 : 14
执行了2,  integer1 : 4 , integer2 : 6
执行了2,  integer1 : 9 , integer2 : 26
执行了2,  integer1 : 3 , integer2 : 10
执行了2,  integer1 : 13 , integer2 : 35

在这种情境下，累加器用来做流中每个元素与初始值的处理，合并器合并它们的结果