Java中的Stream

进击的编程浪人

已于 2024-12-11 15:51:07 修改

阅读量3.7k

点赞数 30

文章标签： java 开发语言

于 2024-12-11 15:50:27 首次发布

本文链接：https://blog.csdn.net/2302_76543887/article/details/144402865

版权

1. 什么是 Stream？

Stream 是 Java 8 引入的一种新方式，目的是帮助我们更简洁、更高效地处理集合（如 List、Set、Map 等）。你可以把 Stream 想象成一条“流水线”，数据就像是流水线上的原材料，经过流水线的各个环节处理，最后你会得到想要的结果。

2. 为什么要使用 Stream？

在没有 Stream 之前，处理集合数据时，我们通常会使用循环来逐个操作每个元素，这样代码冗长、难以维护。

传统做法：

假设我们有一个 List 存储了多个整数，我们想找出所有大于 10 的数字。

List<Integer> numbers = Arrays.asList(5, 12, 15, 8, 22);
List<Integer> result = new ArrayList<>();

for (int num : numbers) {
    if (num > 10) {
        result.add(num);
    }
}
System.out.println(result);  // 输出 [12, 15, 22]

这种方式看起来没问题，但是如果我们需要对多个集合执行各种复杂的操作（过滤、排序、映射等），代码就会变得非常冗长。

使用 Stream：

Stream 让你可以通过一系列简单的“流式操作”来处理数据。

List<Integer> numbers = Arrays.asList(5, 12, 15, 8, 22);
List<Integer> result = numbers.stream()  // 将 List 转换成 Stream
                              .filter(num -> num > 10)  // 过滤大于 10 的元素
                              .collect(Collectors.toList());  // 收集结果为一个新的 List

System.out.println(result);  // 输出 [12, 15, 22]

通过 stream() 方法，我们将 List 转换成了一个 Stream，接着使用了 filter() 来过滤出大于 10 的元素，最后通过 collect() 方法将结果转回 List。

3. 流（Stream）的核心特点

声明式代码：你不需要关心具体的如何循环，Stream 把这些细节帮你处理了，你只需要专注于“做什么”而不是“怎么做”。
支持链式调用：你可以将多个操作连接在一起，像流水线一样一步步处理数据。
惰性求值：Stream 中的操作不会立即执行，直到你调用终端操作时，才会真正执行所有的操作。
可以并行处理：Stream 使得并行处理变得非常简单，特别适用于大数据量的处理。

4. Stream 的基本操作

Stream 主要有两类操作：中间操作 和 终端操作。

1. 中间操作（Intermediate Operations）

中间操作会返回一个新的 Stream，这意味着你可以连续链式调用多个中间操作。中间操作通常是懒执行的，只有在终端操作执行时，所有的中间操作才会一起执行。

常用的中间操作包括：

filter()：过滤数据，返回符合条件的元素。
map()：将每个元素转换成新的形式。
sorted()：对数据进行排序。

示例：

List<Integer> numbers = Arrays.asList(5, 12, 15, 8, 22);

List<Integer> result = numbers.stream()        // 将 List 转换为 Stream
                              .filter(num -> num > 10)  // 过滤出大于 10 的元素
                              .map(num -> num * 2)      // 每个数字乘以 2
                              .sorted()                 // 排序
                              .collect(Collectors.toList());  // 收集结果为一个 List

System.out.println(result);  // 输出 [24, 30, 44]

在这个例子中，我们做了三件事：

先过滤出大于 10 的数字。
然后将每个数字乘以 2。
最后对结果进行排序。

2. 终端操作（Terminal Operations）

终端操作是 Stream 处理的最后一步，执行完终端操作后，Stream 就会被消耗掉，无法继续使用。常见的终端操作有：

collect()：将 Stream 中的元素收集成一个集合。
forEach()：对每个元素执行某个操作。
reduce()：将 Stream 中的所有元素聚合成一个结果（比如求和）。
count()：统计元素的数量。

示例：

List<Integer> numbers = Arrays.asList(5, 12, 15, 8, 22);

// 1. collect()：收集到 List 中
List<Integer> result = numbers.stream()
                              .filter(num -> num > 10)
                              .collect(Collectors.toList());
System.out.println(result);  // 输出 [12, 15, 22]

// 2. forEach()：打印每个元素
numbers.stream()
       .forEach(num -> System.out.println(num));

// 3. reduce()：求和
int sum = numbers.stream()
                 .reduce(0, (a, b) -> a + b);
System.out.println(sum);  // 输出 62

5. 延迟执行与惰性求值

Stream 的操作是惰性执行的，也就是说，Stream 中的操作并不会立即执行，而是等到你真正需要结果时（调用终端操作）才会执行。这种特性让我们可以做一些优化，比如避免不必要的操作。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// 中间操作：过滤和映射
Stream<Integer> stream = numbers.stream()
                                .filter(num -> num > 2)  // 过滤出大于 2 的数字
                                .map(num -> num * 2);     // 每个数字乘以 2

// 终端操作：打印结果
stream.forEach(System.out::println);  // 输出 6, 8, 10

在上面的代码中，filter() 和 map() 是中间操作，只有在调用 forEach()（终端操作）时，才会实际进行数据处理。

6. 并行流（Parallel Stream）

Stream 还支持并行流（parallelStream()），它可以利用多核 CPU 的优势来加速处理。当你需要处理大量数据时，使用并行流可以显著提高效率。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 使用 parallelStream() 进行并行处理
numbers.parallelStream()
       .forEach(num -> System.out.println(num + " processed by " + Thread.currentThread().getName()));