8-归约与汇总

归约与汇总

归约(reduce):将Stream流中元素转化成一个值
汇总(collect):将Stream流中元素转换成一个容器

接口方法

/**
 *第一个参数表示初始值
 *第二个参数表示计算逻辑
 *第三个参数表示合并逻辑
 */
<U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

/**
 *第一个参数表示初始值
 *第二个参数表示计算逻辑
 *第三个参数表示合并逻辑
 */
<R> R collect(Supplier<R> supplier,
                  BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);

代码示例

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;

/**
 * @description: 归约与汇总操作
 */
public class ReduceAndCollectTest {

    @Test
    public void reduceTest() {
        /**
         * 订单对象
         */
        @Data
        @AllArgsConstructor
        class Order {
            /**
             * 订单编号
             */
            private Integer id;
            /**
             * 商品数量
             */
            private Integer productCount;
            /**
             * 消费总金额
             */
            private Double totalAmount;
        }

        /**
         * 准备数据
         */
        List<Order> list = Lists.newArrayList();
        list.add(new Order(1, 2, 25.12));
        list.add(new Order(2, 5, 257.23));
        list.add(new Order(3, 3, 23332.12));

        /**
         * 以前的方式:
         * 1. 计算商品数量
         * 2. 计算消费的总金额
         */

        /**
         * 汇总商品数量和总金额
         */
        Order order = list.stream()
                .parallel()
                .reduce(
                        //初始化的值
                        new Order(0, 0, 0.0),
                        //Stream中两个元素计算逻辑
                        (Order order1, Order order2) -> {
                            System.out.println("执行 计算逻辑 方法");
                            int productCount = order1.getProductCount() + order2.getProductCount();
                            double totalAmount = order1.getTotalAmount() + order2.getTotalAmount();
                            return new Order(0, productCount, totalAmount);
                        },
                        //并行情况下,多个并行结果如何合并
                        (Order order1, Order order2) -> {
                            System.out.println("执行 并行 方法");
                            int productCount = order1.getProductCount() + order2.getProductCount();
                            double totalAmount = order1.getTotalAmount() + order2.getTotalAmount();
                            return new Order(0, productCount, totalAmount);
                        });
        System.out.println(JSON.toJSONString(order, true));
    }

    @Test
    public void collectTest(){
        /**
         * 订单对象
         */
        @Data
        @AllArgsConstructor
        class Order {
            /**
             * 订单编号
             */
            private Integer id;
            /**
             * 用户账号
             */
            private String account;
            /**
             * 商品数量
             */
            private Integer productCount;
            /**
             * 消费总金额
             */
            private Double totalAmount;
        }

        /**
         * 准备数据
         */
        List<Order> list = Lists.newArrayList();
        list.add(new Order(1, "xiaoming", 2, 25.12));
        list.add(new Order(2, "xiaoming", 5, 257.23));
        list.add(new Order(3, "xiaoting", 3, 23332.12));

        /**
         * Map<用户账号,订单(数量和金额)>
         */

        HashMap<String, Order> hashMap = list.stream()
                .parallel()
                .collect(
                        () -> {
                            System.out.println("执行 初始化容器 操作!!!");
                            return new HashMap<String, Order>();
                        },
                        (HashMap<String, Order> map, Order newOrder) -> {
                            System.out.println("执行 新元素添加到容器操作 操作!!!");
                            /**
                             * 新元素的acount已经在map存在了
                             * 不存在
                             */
                            String acount = newOrder.getAccount();
                            if (map.containsKey(acount)) {
                                Order order = map.get(acount);
                                order.setProductCount(
                                        newOrder.getProductCount()
                                                + order.getProductCount());
                            } else {
                                map.put(acount, newOrder);
                            }
                        },
                        (HashMap<String, Order> map1, HashMap<String, Order> map2) -> {
                            System.out.println("执行 并行结果合并 操作!!!");
                            map2.forEach((key, value) -> {
                                map1.merge(key, value, (order1, order2) -> {
                                    //TODO 注意:一定要用map1做合并,因为最后collect返回的是map1
                                    return new Order(0, key,
                                            order1.getProductCount()
                                                    + order2.getProductCount(),
                                            order1.getTotalAmount()
                                                    + order2.getTotalAmount());
                                });
                            });
                        });
        System.out.println(JSON.toJSONString(hashMap, true));
    }
}