Java 8 中的 Stream：优雅的集合处理

news2024/11/25 22:52:30

Java 8 中的 Stream：优雅的集合处理

- 为什么需要 Stream？
- Stream 的特性
- Stream 基本操作
- - 1. 创建 Stream
  - 2. 中间操作
  - - 2.1 过滤（Filter）
    - 2.2 映射（Map）
    - 2.3 截断（Limit）
  - 3. 终端操作
  - - 3.1 遍历（forEach）
    - 3.2 收集（Collect）
    - 3.3 匹配（Match）
- 并行 Stream
- 总结

在Java 8中，引入了一种新的抽象概念——Stream（流），它为集合操作提供了一种极为便利和高效的方式。Stream不是一种数据结构，而是对数据集合进行操作的一种工具，让你能够以一种声明性的方式处理数据。

为什么需要 Stream？

在Java 8之前，我们对集合的操作通常是通过循环来实现的，这样的代码常常显得繁琐、冗长，而且容易引入错误。而引入 Stream 后，可以使用更为直观、简洁的方式进行集合操作，代码更易读、易维护。

Stream 的特性

声明性编程： 使用 Stream 进行集合操作时，只需关注“做什么”而不是“怎么做”。这种声明性的风格让代码更为清晰。
可并行： Stream 提供了并行处理的能力，能够充分利用多核处理器的优势，提高处理大数据集合的效率。
内部迭代： 与外部迭代相比，Stream 使用内部迭代，可以自动选择最优的方法来实现操作，无需手动干预。

Stream 基本操作

1. 创建 Stream

// 从集合创建 Stream
List<String> list = Arrays.asList("apple", "banana", "orange");
Stream<String> streamFromList = list.stream();

// 从数组创建 Stream
String[] array = {"apple", "banana", "orange"};
Stream<String> streamFromArray = Arrays.stream(array);

// 创建一个空的 Stream
Stream<String> emptyStream = Stream.empty();

// 通过 Stream.of() 创建 Stream
Stream<String> streamOf = Stream.of("apple", "banana", "orange");

2. 中间操作

中间操作返回一个新的 Stream，并可以进行链式调用。

2.1 过滤（Filter）

List<String> fruits = Arrays.asList("apple", "banana", "orange", "grape", "kiwi");

List<String> result = fruits.stream()
                           .filter(s -> s.length() > 5)
                           .collect(Collectors.toList());

System.out.println(result); // Output: [banana, orange]

2.2 映射（Map）

List<String> fruits = Arrays.asList("apple", "banana", "orange");

List<Integer> result = fruits.stream()
                           .map(String::length)
                           .collect(Collectors.toList());

System.out.println(result); // Output: [5, 6, 6]

2.3 截断（Limit）

List<String> fruits = Arrays.asList("apple", "banana", "orange");

List<String> result = fruits.stream()
                           .limit(2)
                           .collect(Collectors.toList());

System.out.println(result); // Output: [apple, banana]

3. 终端操作

终端操作触发 Stream 的处理，并返回结果。每个 Stream 只能进行一次终端操作。

3.1 遍历（forEach）

List<String> fruits = Arrays.asList("apple", "banana", "orange");

fruits.stream()
      .forEach(System.out::println);

3.2 收集（Collect）

List<String> fruits = Arrays.asList("apple", "banana", "orange");

List<String> result = fruits.stream()
                           .filter(s -> s.length() > 5)
                           .collect(Collectors.toList());

System.out.println(result); // Output: [banana, orange]

3.3 匹配（Match）

List<String> fruits = Arrays.asList("apple", "banana", "orange");

boolean anyMatch = fruits.stream()
                        .anyMatch(s -> s.startsWith("b"));

boolean allMatch = fruits.stream()
                        .allMatch(s -> s.length() > 3);

boolean noneMatch = fruits.stream()
                         .noneMatch(s -> s.endsWith("k"));

System.out.println(anyMatch);    // Output: true
System.out.println(allMatch);    // Output: false
System.out.println(noneMatch);   // Output: true

并行 Stream

Stream 提供了并行处理的方法，通过 parallel() 将串行 Stream 转换为并行 Stream。

List<String> fruits = Arrays.asList("apple", "banana", "orange", "grape", "kiwi");

List<String> result = fruits.parallelStream()
                           .filter(s -> s.length() > 5)
                           .collect(Collectors.toList());

System.out.println(result); // Output: [banana, orange]