使用Stream流操作list

Java Stream 是 Java 8 中引入的一个新特性，它允许您以声明式方式处理数据集合，从而使代码更加简洁、易读。Stream API 提供了一组丰富的方法，用于对集合进行各种操作，如过滤、映射、排序等。

创建 Stream

要创建 Stream，您可以使用各种方法从集合中获取 Stream 实例。例如，您可以使用 Arrays.stream() 方法从数组中创建 Stream，或使用 list.stream() 方法从 List 中创建 Stream。

int[] arr = {1, 2, 3, 4, 5};  
Stream<Integer> stream = Arrays.stream(arr);
/**
* 报错：Error:(43, 65) java: 不兼容的类型: java.util.stream.IntStream无法转换为java.util.stream.Stream<java.lang.Integer>
* 注意：Arrays.stream(arr) 返回的是 IntStream 类型，而不是 Stream<Integer>。IntStream 是 Java 8 引入的用于原始整数类型（如 int、long 等）的流，而 Stream<Integer> 是用于包装类型（如 Integer）的流。为了将 IntStream 转换为 Stream<Integer>，你可以使用 boxed() 方法，该方法会将原始整数流转换为包装整数流。
**/
//解决方法改为
Stream<Integer> stream = Arrays.stream(arr).boxed();
  
List<String> list = Arrays.asList("a", "b", "c", "d");  
Stream<String> stringStream = list.stream();

结果：

基本操作

过滤： 使用 filter() 方法可以过滤掉 Stream 中的元素。

Stream<Integer> evenNumbers = stream.filter(n -> n % 2 == 0);

映射： 使用 map() 方法可以将一个元素转换成另一个元素。

Stream<String> upperCase = stringStream.map(String::toUpperCase);

排序：使用 sorted() 方法可以对 Stream 中的元素进行排序。

Stream<String> sorted = stringStream.sorted();

收集：使用 collect() 方法可以将 Stream 中的元素收集到一个集合中。

List<String> resultList = sorted.collect(Collectors.toList());

终止操作

终止操作是指那些在 Stream 处理完毕后执行的操作，如 forEach()、reduce() 等。这些操作会消耗 Stream 中的元素，因此只能执行一次。

forEach()：用于对 Stream 中的每个元素执行某个操作。

upperCase.forEach(System.out::println);

reduce()：用于对 Stream 中的元素进行归约操作，例如求和或连接字符串。

int sum = stream.reduce(0, Integer::sum);  
String joined = stringStream.reduce("", String::concat);

中间操作

中间操作是指那些不消耗 Stream 中的元素的操作，如 limit()、skip() 等。这些操作不会改变 Stream 中的元素，因此可以多次执行。

limit()：限制 Stream 中的元素数量。
skip()：跳过 Stream 中的前几个元素。
sorted()：对 Stream 中的元素进行排序。注意这个操作会改变元素的顺序。

使用Stream流对list进行分页
方法一：

   // 假设这是你的原始列表  
        List<String> items = Arrays.asList("item1", "item2", "item3", "item4", "item5", "item6", "item7", "item8", "item9", "item10"); 
  
        // 分页参数  
        int pageSize = 3; // 每页3个元素  
        int currentPage = 1; // 当前页码  
  
        // 使用IntStream生成分页的索引  
        IntStream pageIndexes = IntStream.range(0, items.size())  
                                         .filter(i -> i / pageSize == currentPage - 1)  // 过滤出当前页的索引  
                                         .map(i -> i + (currentPage - 1) * pageSize); // 调整索引以匹配起始位置  
  
        // 使用Stream API提取分页的元素  
        List<String> pageItems = pageIndexes.mapToObj(items::get)  
                                            .collect(Collectors.toList());  
  
        // 打印分页的元素  
        System.out.println(pageItems);  

方法二：

// 假设这是你的原始列表  
        List<String> items = Arrays.asList("item1", "item2", "item3", "item4", "item5", "item6", "item7", "item8", "item9", "item10"); 
  
        // 分页参数  
        int pageSize = 3; // 每页3个元素  
        int currentPage = 1; // 当前页码  
  
        // 使用Stream API进行分页  
        List<String> pageItems = items.stream()  
                                       .skip((currentPage - 1) * pageSize) // 跳过前面的元素  
                                       .limit(pageSize) // 限制结果的元素数量  
                                       .collect(Collectors.toList()); // 将结果收集到一个列表中  
  
        // 打印分页的元素  
        System.out.println(pageItems);  
    }  

对list进行筛选

            List<VoucherSubOutPutVo> subOutPutVoList = subOutPutVos.stream()
                    .filter(outPutVo -> {
                        // 条件1：条件为空时不使用该条件筛选
                        if (StringUtils.isNotEmpty(requestIn.getInvoiceCode())) {
                            if (outPutVo.getInvoiceCode().equals(requestIn.getInvoiceCode())) {
                                return true;
                            } else {
                                return false;
                            }
                        } else {
                            return true;  // 条件为空时，直接添加到筛选结果中
                        }
                    })
                    .filter(outPutVo -> {
                        // 条件1：条件为空时不使用该条件筛选
                        if (StringUtils.isNotEmpty(requestIn.getInvoiceNo())) {
                            if (outPutVo.getInvoiceNo().equals(requestIn.getInvoiceNo())) {
                                return true;
                            } else {
                                return false;
                            }
                        } else {
                            return true;  // 条件为空时，直接添加到筛选结果中
                        }
                    })
                    .filter(outPutVo -> {
                        // 条件1：条件为空时不使用该条件筛选
                        if (StringUtils.isNotEmpty(requestIn.getThrowableType())) {
                            if (outPutVo.getThrowableType().equals(requestIn.getThrowableType())) {
                                return true;
                            } else {
                                return false;
                            }
                        } else {
                            return true;  // 条件为空时，直接添加到筛选结果中
                        }
                    })
                    .filter(outPutVo -> {
                        // 条件1：条件为空时不使用该条件筛选
                        if (StringUtils.isNotEmpty(requestIn.getInvoiceType())) {
                            if (outPutVo.getInvoiceType().equals(requestIn.getInvoiceType())) {
                                return true;
                            } else {
                                return false;
                            }
                        } else {
                            return true;  // 条件为空时，直接添加到筛选结果中
                        }
                    })
                    .filter(outPutVo -> {
                        // 条件1：条件为空时不使用该条件筛选
                        if (StringUtils.isNotEmpty(requestIn.getVoucherNumber())) {
                            if (outPutVo.getVoucherNumber().equals(requestIn.getVoucherNumber())) {
                                return true;
                            } else {
                                return false;
                            }
                        } else {
                            return true;  // 条件为空时，直接添加到筛选结果中
                        }
                    })
                    .filter(outPutVo -> {
                        // 条件1：条件为空时不使用该条件筛选
                        if (StringUtils.isNotEmpty(requestIn.getSubjectCode())) {
                            if (outPutVo.getSubjectCode().equals(requestIn.getSubjectCode())) {
                                return true;
                            } else {
                                return false;
                            }
                        } else {
                            return true;  // 条件为空时，直接添加到筛选结果中
                        }
                    })
                    .filter(outPutVo -> {
                        // 条件1：条件为空时不使用该条件筛选
                        if (StringUtils.isNotEmpty(requestIn.getDataSources())) {
                            if (outPutVo.getDataSources().equals(requestIn.getDataSources())) {
                                return true;
                            } else {
                                return false;
                            }
                        } else {
                            return true;  // 条件为空时，直接添加到筛选结果中
                        }
                    })
                    .collect(Collectors.toList());