函数式编程之stream开发实战

一、过滤filter、去重distinct

filter方法，过滤元素相当于 if；
distinct方法是去重会返回一个元素各异的流，原理就是根据流里面的元素的hashCode和equals方法实现的

@Data
@NoArgsConstructor
@AllArgsConstructor
public class OrderInfo {
    private String orderId;
    private BigDecimal orderAmt;

    public static void main(String[] args) {

        List<OrderInfo> orderInfos = Arrays.asList(new OrderInfo("123", BigDecimal.TEN), new OrderInfo("456",
                BigDecimal.ONE),new OrderInfo("123", BigDecimal.ZERO));

        // distinct — 订单号去重
        List<String> collect = orderInfos.stream().map(OrderInfo::getOrderId)
                .distinct().collect(toList());

        // filter — 过滤大于5元的订单
        List<OrderInfo> collect1 = orderInfos.stream()
                .filter(orderInfo -> orderInfo.getOrderAmt().compareTo(new BigDecimal("5")) > 0)
                .collect(toList());

        System.out.println(collect);   // [123, 456]
        System.out.println(collect1);  // [OrderInfo(orderId=123, orderAmt=10)]
    }
}

二、映射（map、flatMap）

map方法会接受一个函数作为参数，函数被应用到每个元素上，并创建一个新的元素（map是创建一个新的元素，而不是修改）；
将流扁平化flatMap，将每个集合、数组合称为一个流

@Data
@NoArgsConstructor
@AllArgsConstructor
public class OrderInfo {
    private String orderId;
    private BigDecimal orderAmt;
    private List<SubOrderInfo> subOrderInfoList;
    
    public static void main(String[] args) {
        List<OrderInfo> orderInfoList = Arrays.asList(new OrderInfo("123", BigDecimal.ONE, Arrays.asList(new SubOrderInfo("2020123"))),
                new OrderInfo("456", BigDecimal.TEN, Arrays.asList(new SubOrderInfo("2023117"))));

        // flatMap - 将代码中 List 中的 List 合并为一个List
        List<SubOrderInfo> collect6 = orderInfoList.stream().map(OrderInfo::getSubOrderInfoList).flatMap(subOrderInfos -> subOrderInfos.stream()).collect(toList());
        System.out.println(collect6);  // [SubOrderInfo{subOrderId='2020123'}, SubOrderInfo{subOrderId='2020456'}]

        // map - 映射一个新的数据结构
        List<List<SubOrderInfo>> collect7 = orderInfoList.stream().map(OrderInfo::getSubOrderInfoList).collect(toList());
        System.out.println(collect7);  // [[SubOrderInfo{subOrderId='2020123'}], [SubOrderInfo{subOrderId='2020456'}]]

 

        //map- 获取订单id集合
        List<String> orderIdList = orderInfoList.stream().map(OrderInfo::getOrderId).collect(toList());
        System.out.println(orderIdList); //[123, 456]
    }
}

三、归约、汇总、计算（reduce、Collectors、IntStream、DoubleStream、LongStream）

        // 计算全部子订单的交易金额
        BigDecimal totalSubOrderAmt = orderInfos.stream()
                .map(OrderInfo::getSubOrderInfoList)
                .flatMap(subOrderInfos -> subOrderInfos.stream())
                .filter(subOrderInfo -> null != subOrderInfo.getSubOrderAmt())
                .map(SubOrderInfo::getSubOrderAmt)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        System.out.println(totalSubOrderAmt);

reduce支持更复杂的合并（归约、汇总）、可以求和、最大值最小值等等，这个在计算金额的时候经常会用到

四、创建流（Stream.of、Stream.ofNullable、Arrays.stream）

流创建有很多种， 例如 :集合.stream，同时我们还可以使用一些其他的方式创建，Stream.of() 通过显示值创建流、Stream.ofNullable，创建一个可以是空的流、Arrays.stream、Files.lines

        Stream<OrderInfo> of = Stream.of(new OrderInfo("123", BigDecimal.ONE, "2020123"));
 
        Stream<OrderInfo> of1 = Stream.ofNullable(null);
 
        int[] num = {1, 2, 3, 4, 5};
        int sum = Arrays.stream(num).sum();

五、查找、匹配（allMatch、anyMatch、noneMatch、findFirst、findAny）

anyMatch查找流中是否有匹配的元素；allMatch判断是否匹配所有元素；noneMatch是allMatch的反向逻辑，查找是否都不匹配
findFirst和findAny，查找元素，findFirst找到第一个元素返回，findAny可以返回任意元素

        List<OrderInfo> orderInfoList = Arrays.asList(new OrderInfo("123", BigDecimal.ONE, "2020123"),
                new OrderInfo("456", BigDecimal.TEN, "2020456"), new OrderInfo("456", BigDecimal.TEN, "2020456"));
 
        // findAny/findFirst 查找支付金额大于1的,并返回
        Optional<OrderInfo> collect8 = orderInfoList.stream()
                .filter(orderInfo -> orderInfo.getOrderAmt().compareTo(BigDecimal.ONE) > 0)
                .findAny();
        System.out.println(collect8.map(OrderInfo::getOrderId));  // Optional[456]
 
        Optional<OrderInfo> collect9 = orderInfoList.stream()
                .filter(orderInfo -> orderInfo.getOrderAmt().compareTo(BigDecimal.ONE) > 0)
                .findFirst();
        System.out.println(collect9.map(OrderInfo::getOrderId));  // Optional[123]
 
        // allMatch/anyMatch/noneMatch 校验金额是否大于1，并返回boolean值
        boolean a = orderInfoList.stream().allMatch(orderInfo -> orderInfo.getOrderAmt().compareTo(BigDecimal.ONE) > 0);
        boolean b = orderInfoList.stream().anyMatch(orderInfo -> orderInfo.getOrderAmt().compareTo(BigDecimal.ONE) > 0);
        boolean c = orderInfoList.stream().noneMatch(orderInfo -> orderInfo.getOrderAmt().compareTo(BigDecimal.ONE) > 0);
        System.out.println(a + " " + b + " " + c);  // false true false

六、切片、截断、跳过（takeWhile、dropWhile、limit、skip）

Java9中引入了takeWhile、dropWhile，可以高效选择流中的元素，takeWhile相当于 if + return，当遇到第一个不符合要求的元素的时候停止流；dropWhile 是takeWhile 的补充，他丢弃 false的元素，一旦结果为true，流就会停止，并返回所有剩余元素。
limit就是 截断，返回一个长度不超过 n 的流，n 是前n的元素，跳过元素，skip 返回一个扔掉 n 个元素的流，limit skip属于互补的两个方法。

        // java9 takeWhil/dropWhile - 切片
        List<OrderInfo> collect2 = orderInfos.stream()
                .takeWhile(orderInfo -> orderInfo.getOrderAmt().compareTo(BigDecimal.ONE) > 0).collect(toList());
        List<OrderInfo> collect3 = orderInfos.stream()
                .dropWhile(orderInfo -> orderInfo.getOrderAmt().compareTo(BigDecimal.ONE) > 0).collect(toList());
 
        System.out.println(collect2);  // [OrderInfo{orderId='123', orderAmt=10}]
        System.out.println(collect3);  // [OrderInfo{orderId='456', orderAmt=1}]
 
        // limit - 截断，返回一个长度不超过10的流
        List<OrderInfo> collect4 = orderInfos.stream().limit(10).collect(toList());
        // skip - 跳过元素，返回一个前端扔点10个元素的流
        List<OrderInfo> collect5 = orderInfos.stream().skip(10).collect(toList());
        
        System.out.println(collect4);  // [OrderInfo{orderId='123', orderAmt=10}, OrderInfo{orderId='456', orderAmt=1}]
        System.out.println(collect5);  // []

七、总结

本讲讲解了大量且常用必用的Stream api使用，下面补充一些常用的案例

7.1分页

  //dtoList -> 当前页所有数据
 List<ProjectDTO> dtoList = list.stream().skip((pageNo - 1) * pageSize).limit(pageSize).collect(Collectors.toList()));

//总条数
dto.setPages(pageNo);
dto.setTotal(list.size());
dto.setList(dtoList);

skip：跳过n个元素，limit裁剪大小，pageNo 当前页，pageSize当前页大小。