lambda表达式

1.代码演变历史

2.lambda简介

3.函数式接口

3.1定义

3.2常用函数

4.方法引用

5.Stream流编程

5.1流是什么?

1.Java8引入的新成员，以声明式方式处理集合数据
2.将基础操作链接起来，完成复杂的数据处理流水线
3.提供透明的并行处理能力

5.2流和集合的区别

1. 时间与空间
2. 只能遍历一次
3. 外部迭代与内部迭代

5.3流的组成

1. 数据源

2. 中间操作

3. 终端操作

5.4流的操作

5.5三种构建流的方式

5.6收集器

5.6.1三种收集器

5.6.2规约和汇总

汇总:将两个容器计算后合并成为一个容器,例如两个订单的价格汇总成为一个订单的总价格

规约:返回值是Map<String,Order)集合,判断Map中是否已经存在order,如果存在就进行更新操作,不存在就添加到Map集合中

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);
            });

Map<String, Order> collect = list.stream()
      .parallel()
      .collect(
            () -> {
               System.out.println("执行 初始化容器 操作！！！");

               return new HashMap<String, Order>();
            },
            (HashMap<String, Order> map, Order newOrder) -> {
               System.out.println("执行 新元素添加到容器 操作！！！");

            /*
            新元素的account已经在map中存在了
            不存在
            */
               String account = newOrder.getAccount();

               // 如果此账号已存在，将新订单数据累加上
               if (map.containsKey(account)) {
                  Order order = map.get(account);
                  order.setProductCount(
                        newOrder.getProductCount()
                              + order.getProductCount());
                  order.setTotalAmount(
                        newOrder.getTotalAmount()
                              + order.getTotalAmount());
               } else {
                  // 如果不存在，直接将新订单存入map
                  map.put(account, 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());
                  });
               });
            });

6.Optional解析

https://www.cnblogs.com/zhangboyu/p/7580262.html](https://www.cnblogs.com/zhangboyu/p/7580262.html)

// 结果解析
PageResult pageResult = new PageResult();
pageResult.setPageNo((int) userDOIPage.getCurrent());
pageResult.setPageSize((int) userDOIPage.getSize());
pageResult.setTotal(userDOIPage.getTotal());
pageResult.setPageNum(userDOIPage.getPages());



// 对数据进行转换
List<UserDTO> userDTOList = Optional
        .ofNullable(userDOIPage.getRecords())
        .map(List::stream)
        .orElseGet(Stream::empty)
        .map(userDO -> {
            UserDTO userDTO = new UserDTO();
            BeanUtils.copyProperties(userDO, userDTO);
            return userDTO;
        })
        .collect(Collectors.toList());

pageResult.setData(userDTOList);

return pageResult;