为什么要使用stream流

news2025/5/29 6:39:06

总的来说就是

它支持链式调用，方便

不会修改原始数据源，而是生成一个新的流或结果

中间操作不会立即执行，只有在终端操作触发时才会真正执行

注意事项

无状态操作：Stream 操作应该是无状态的，不要依赖外部变量的状态。
副作用：避免在 Stream 操作中修改外部变量，可能导致不确定的行为。
线程安全：并行流可能会导致线程安全问题，需谨慎使用。

以下是相关知识点：

Java 8 引入了 Stream API，它提供了一种高效且简洁的方式来处理集合数据。Stream 是一种抽象，它允许你以声明式的方式处理数据集合（如 List、Set 等）。Stream API 的设计灵感来源于函数式编程语言，并结合了 Java 的特性。

1. Stream 的核心概念

（1）什么是 Stream？

定义：Stream 是一个来自数据源的元素序列，支持顺序和并行的聚合操作。
特点：
- 惰性求值（Lazy Evaluation）：Stream 的中间操作不会立即执行，只有在终端操作触发时才会真正执行。
- 不可变性：Stream 操作不会修改原始数据源，而是生成一个新的流或结果。
- 链式调用：Stream 支持链式调用，可以将多个操作串联起来。

（2）Stream 的生命周期

Stream 的生命周期分为三个阶段：

创建 Stream：从数据源（如集合、数组、文件等）创建一个 Stream。
中间操作（Intermediate Operations）：对 Stream 进行一系列转换操作（如过滤、映射等），返回一个新的 Stream。
终端操作（Terminal Operations）：触发 Stream 的执行并生成最终结果（如收集到集合中、计算总数等）。

2. Stream 的创建方式

（1）从集合创建


List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream(); // 创建顺序流
Stream<String> parallelStream = list.parallelStream(); // 创建并行流

（2）从数组创建


String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

（3）使用 `Stream.of`


Stream<String> stream = Stream.of("a", "b", "c");

（4）生成无限流

Stream.generate：生成一个无限流。


  Stream<Double> randomStream = Stream.generate(Math::random);

Stream.iterate：基于初始值和递增规则生成一个无限流。


  Stream<Integer> evenNumbers = Stream.iterate(0, n -> n + 2);

3. Stream 的中间操作

中间操作会返回一个新的 Stream，它们是惰性的，只有在终端操作触发时才会执行。

（1）`filter`

作用：过滤掉不符合条件的元素。
示例：


  Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
  Stream<Integer> filtered = numbers.filter(n -> n % 2 == 0); // 只保留偶数

（2）`map`

作用：将每个元素映射为另一个元素。
示例：


  Stream<String> words = Stream.of("apple", "banana", "cherry");
  Stream<Integer> lengths = words.map(String::length); // 获取每个单词的长度

（3）`flatMap`

作用：将每个元素映射为一个流，然后将所有流合并为一个流。
示例：


  List<List<Integer>> nestedList = Arrays.asList(
      Arrays.asList(1, 2),
      Arrays.asList(3, 4)
  );
  Stream<Integer> flatStream = nestedList.stream().flatMap(List::stream);

（4）`distinct`

作用：去重，返回一个不包含重复元素的流。
示例：


  Stream<Integer> numbers = Stream.of(1, 2, 2, 3, 3);
  Stream<Integer> distinctNumbers = numbers.distinct();

（5）`sorted`

作用：排序流中的元素。
示例：


  Stream<Integer> numbers = Stream.of(3, 1, 2);
  Stream<Integer> sortedNumbers = numbers.sorted();

（6）`limit` 和 `skip`

作用：
- limit(n)：截取前 n 个元素。
- skip(n)：跳过前 n 个元素。
示例：


  Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
  Stream<Integer> limited = numbers.limit(3); // 取前 3 个元素
  Stream<Integer> skipped = numbers.skip(2);  // 跳过前 2 个元素

4. Stream 的终端操作

终端操作会触发 Stream 的执行，并生成最终结果。

（1）`forEach`

作用：遍历流中的每个元素。
示例：


  Stream<String> words = Stream.of("hello", "world");
  words.forEach(System.out::println);

（2）`collect`

作用：将流中的元素收集到集合或其他数据结构中。
示例：


  Stream<String> words = Stream.of("a", "b", "c");
  List<String> list = words.collect(Collectors.toList());

（3）`reduce`

作用：通过某种操作将流中的元素合并为一个值。
示例：


  Stream<Integer> numbers = Stream.of(1, 2, 3, 4);
  Optional<Integer> sum = numbers.reduce((a, b) -> a + b); // 计算总和

（4）`anyMatch`、`allMatch` 和 `noneMatch`

作用：
- anyMatch：判断是否有任意一个元素满足条件。
- allMatch：判断是否所有元素都满足条件。
- noneMatch：判断是否没有任何元素满足条件。
示例：


  Stream<Integer> numbers = Stream.of(1, 2, 3, 4);
  boolean anyEven = numbers.anyMatch(n -> n % 2 == 0); // 是否有偶数

（5）`count`

作用：统计流中的元素数量。
示例：


  Stream<Integer> numbers = Stream.of(1, 2, 3, 4);
  long count = numbers.count(); // 统计元素数量

（6）`findFirst` 和 `findAny`

作用：
- findFirst：返回流中的第一个元素（如果存在）。
- findAny：返回流中的任意一个元素（通常用于并行流）。
示例：


  Stream<Integer> numbers = Stream.of(1, 2, 3, 4);
  Optional<Integer> first = numbers.findFirst();

5. 惰性求值（Lazy Evaluation）

Stream 的中间操作是惰性的，只有在终端操作触发时才会真正执行。这种机制的优点包括：

性能优化：避免不必要的计算。
短路操作：某些操作（如 findFirst 或 anyMatch）可以在满足条件后立即停止。

6. 并行流（Parallel Streams）

定义：并行流利用多核处理器的能力，将任务分解为多个子任务并行执行。
示例：


  List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
  int sum = numbers.parallelStream()
                   .mapToInt(Integer::intValue)
                   .sum();