Java中stream()的使用

一.stream()是什么

Stream API 提供了一种高级的抽象，使我们可以将集合转换成一种流式的处理模式，从而能大链式地执行一系列操作。

简单来说：就是把集合变成一个流，让我们能持续地在这个流上执行我们想要的操作

流的主要特点

1. 不存储数据：流不会改变原有的数据结构，它们只提供了一种在数据源上执行操作的方法。

2. 函数式操作：流的操作通常是函数式的，意味着你可以传递 lambda 表达式或方法引用来执行操作。

3. 惰性求值：流的中间操作不会立即执行，只有在遇到终端操作时才会执行。这意味着中间操作会形成一种流水线，只有当结果真正需要时才开始计算，这有助于优化性能，特别是在处理大数据或复杂操作链时。

4. 可并行：流可以很容易地并行处理，利用多核处理器来提高性能，只需要将 stream() 方法替换为 parallelStream() 方法。

二.stream的使用步骤

Stream 操作分为中间操作和终端操作
其中中间操作返回的仍然是一个 Stream，允许多个操作连续进行
终端操作则会输出一个结果或产生一个副作用。

步骤：

1. 创建 Stream：

   • 从集合或数组等数据源创建 Stream。
   • 使用 Stream 类的静态方法，如 Stream.of。

2. 执行中间操作：

   • 中间操作如 filter, map, sorted 等，每一个操作都会返回一个新的 Stream 对象，可以继续进行其他中间操作。

3. 执行终端操作：

   • 终端操作如 forEach, collect, reduce 等，这些操作会关闭 Stream 并生成结果。

三.常见的中间操作和终端操作

中间操作

中间操作返回的是另一个 Stream，允许进一步操作。

1. filter(Predicate<T>)：
   过滤流中的元素。只包括符合给定谓词的元素。

   list.stream().filter(x -> x > 10)  // 筛选出大于10的元素
   

2. map(Function<T, R>)：
   将流中的每个元素转换成另一形式，通过给定的函数应用于每个元素。

   list.stream().map(x -> x * x)  // 将每个元素替换为其平方
   

3. flatMap(Function<T, Stream<R>>)：
   与 map 类似，但是每个输入元素都可以映射到多个输出元素（即一个元素列表）。

   list.stream().flatMap(x -> Stream.of(x, x + 1))  // 将每个元素转换为多个元素
   

4. sorted() 和 sorted(Comparator<T>)：
   对流中的元素进行自然排序或使用自定义比较器排序。

   list.stream().sorted()  // 自然排序
   list.stream().sorted(Comparator.reverseOrder())  // 逆序
   

5. distinct()：
   返回一个包含独特元素的流（根据 Object.equals(Object) 方法去重）。

   list.stream().distinct()
   

6. limit(long n) 和 skip(long n)：
   limit 截取流的前 n 个元素；skip 则是跳过前 n 个元素。

   list.stream().limit(5)  // 取前5个元素
   list.stream().skip(5)  // 跳过前5个元素
   

终端操作

终端操作会从流的管道生成结果。

1. forEach(Consumer<T>)：
   对每个元素执行给定的操作。

   list.stream().forEach(System.out::println)  // 打印每个元素
   

2. collect(Collector<T, A, R>)：
   将流转换成其他形式，是一个非常强大的操作，特别是 Collectors 类提供了很多便捷方法。

   List<Integer> newList = list.stream().collect(Collectors.toList());  // 收集到 List
   

3. reduce(BinaryOperator<T>)：
   通过重复使用给定的操作，将流中的元素组合起来，返回一个 Optional。

   Optional<Integer> sum = list.stream().reduce(Integer::sum);  // 求和
   

4. anyMatch(Predicate<T>), allMatch(Predicate<T>), noneMatch(Predicate<T>)：
   检查流中的元素是否至少有一个（anyMatch）、所有元素（allMatch）、没有元素（noneMatch）匹配给定的谓词。

   boolean hasEven = list.stream().anyMatch(x -> x % 2 == 0);  // 检查是否有偶数
   

5. count()：
   返回流中的元素个数。

   long count = list.stream().count();
   

6. min(Comparator<T>) 和 max(Comparator<T>)：
   根据给定的比较器返回流中的最小值或最大值。

   Optional<Integer> min = list.stream().min(Integer::compare);
   Optional<Integer> max = list.stream().max(Integer::compare);
   

四.示例

List<Employee> employees = getEmployees(); // 假设这是从数据库或其他地方获取的员工列表
List<Employee> filteredEmployees = employees.stream()   // 创建 Stream
    .filter(e -> e.getAge() > 30)           // 过滤年龄
    .sorted(Comparator.comparing(Employee::getName))  // 按名字排序
    .collect(Collectors.toList());          // 收集到新的列表