Stream之reduce归约的使用

reduce 归纳

    @Test
    public void reduceTest(){

        @Data
        @AllArgsConstructor
        class Order{
            private Integer id;//订单编号
            private Integer productCount;//商品数量
            private Double totalAmount;//消费总金额
        }

        //准备数据
        List<Order> list = new ArrayList<>();
        list.add(new Order(1,2,435.00));
        list.add(new Order(2,4,4354.12));
        list.add(new Order(3,20,4335.02));

        /**
         * 要求：
         * 1.计算商品数量
         * 2.计算消费总金额
         */

        Order order = list.stream()
                .parallel() //参数3的执行前提是执行该条语句，即并行操作
                .reduce(
                        //初始值
                        new Order(0, 0, 0.0),
                        //第二个参数：Stream中两个元素的计算逻辑
                        (Order o1, Order o2) -> {
                            System.out.println("执行 计算逻辑 部分");
                            int productCount = o1.getProductCount() + o2.getProductCount();
                            double totalAmount = o1.getTotalAmount() + o2.getTotalAmount();
                            return new Order(0, productCount, totalAmount);
                        },
                        //并行情况下，多个并行结果如何合并
                        //如果是并行计算，那多个并行计算的结果是如何汇总的呢？
                        //或者说，第三个参数是：汇总并行计算的逻辑
                        (Order o1, Order o2) -> {
                            System.out.println("执行 合并逻辑");
                            int productCount = o1.getProductCount() + o2.getProductCount();
                            double totalAmount = o1.getTotalAmount() + o2.getTotalAmount();
                            return new Order(0, productCount, totalAmount);
                        });

        System.out.println(JSON.toJSONString(order,true));
    }

补充：reduce的参数3是BinaryOperator combiner ，对其进行说明（如下）。
但是涉及底层源码太深了，我也没太明白BinaryOperator 在底层是如何实现的，只知道是为并发准备的。

U reduce(U identity,
         BiFunction<U, ? super T, U> accumulator,
         BinaryOperator<U> combiner);

/**
 * 表示对两个相同类型的操作数的操作。产生与操作数相同类型的结果。
 * 这是BiFunction的一个特殊例子，它的结果和操作数都是相同的数据类型。
 * 这个是一个函数式接口，该接口有一个函数方法apply(Object,Object)。
 * @param <T> 操作数和结果的数据类型
 * @since 1.8
 */
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
    /**
     * 通过比较器Comparator来比较两个元素中较小的一个作为返回值返回。
     * @param <T> 比较器的输入参数的类型
     * @param comparator 用来比较两个值的Comparator
     * @return 通过比较器Comparator来比较两个元素中较小的一个作为返回值返回。
     * @throws 如果参数为NULL,就会抛出NullPointerException异常
     */
    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

    /**
     * 通过比较器Comparator来比较两个元素中较大的一个作为返回值返回。
     * @param <T> 比较器的输入参数的类型
     * @param comparator 用来比较两个值的Comparator
     * @return 通过比较器Comparator来比较两个元素中较小的一个作为返回值返回。
     * @throws 如果参数为NULL,就会抛出NullPointerException异常
     */
    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

相关实践代码