Java中Stream流的详细使用介绍

1. 创建 Stream

可以通过多种方式创建 Stream：

从集合创建

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

从数组创建

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

使用 Stream.of 创建

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

创建无限流

Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1); // 从 0 开始，每次加 1
Stream<Double> randomStream = Stream.generate(Math::random);    // 生成随机数流

2. 中间操作

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

过滤：filter

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> result = list.stream()
                          .filter(s -> s.startsWith("a")) // 过滤以 "a" 开头的字符串
                          .collect(Collectors.toList());
// 结果：["apple"]

映射：map

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<Integer> result = list.stream()
                           .map(String::length) // 将字符串映射为其长度
                           .collect(Collectors.toList());
// 结果：[5, 6, 6]

去重：distinct

List<String> list = Arrays.asList("apple", "banana", "apple");
List<String> result = list.stream()
                          .distinct() // 去重
                          .collect(Collectors.toList());
// 结果：["apple", "banana"]

排序：sorted

List<String> list = Arrays.asList("banana", "apple", "cherry");
List<String> result = list.stream()
                          .sorted() // 自然排序
                          .collect(Collectors.toList());
// 结果：["apple", "banana", "cherry"]

截取：limit 和 skip

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = list.stream()
                           .skip(2)  // 跳过前 2 个元素
                           .limit(2) // 只取 2 个元素
                           .collect(Collectors.toList());
// 结果：[3, 4]

3. 终端操作

终端操作会触发流的处理，并返回一个非流的结果。

收集：collect

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> result = list.stream()
                          .filter(s -> s.startsWith("a"))
                          .collect(Collectors.toList());
// 结果：["apple"]

遍历：forEach

List<String> list = Arrays.asList("apple", "banana", "cherry");
list.stream().forEach(System.out::println);
// 输出：
// apple
// banana
// cherry

匹配：anyMatch、allMatch、noneMatch

List<String> list = Arrays.asList("apple", "banana", "cherry");
boolean anyStartsWithA = list.stream().anyMatch(s -> s.startsWith("a")); // 是否有以 "a" 开头的
boolean allStartsWithA = list.stream().allMatch(s -> s.startsWith("a")); // 是否全部以 "a" 开头
boolean noneStartsWithZ = list.stream().noneMatch(s -> s.startsWith("z")); // 是否没有以 "z" 开头的

计数：count

List<String> list = Arrays.asList("apple", "banana", "cherry");
long count = list.stream().filter(s -> s.startsWith("a")).count();
// 结果：1

聚合：reduce

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().reduce(0, Integer::sum); // 求和
// 结果：15

4. 并行流

通过 parallelStream() 或 stream().parallel() 可以将流转换为并行流，利用多核处理器加速处理。

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> result = list.parallelStream()
                          .filter(s -> s.startsWith("a"))
                          .collect(Collectors.toList());
// 结果：["apple"]

5. 常用工具类：Collectors

Collectors 提供了丰富的工具方法，用于将流转换为集合或其他数据结构。

转换为列表：toList

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> result = list.stream().collect(Collectors.toList());

转换为集合：toSet

Set<String> set = list.stream().collect(Collectors.toSet());

转换为映射：toMap

Map<String, Integer> map = list.stream()
                               .collect(Collectors.toMap(s -> s, String::length));
// 结果：{"apple": 5, "banana": 6, "cherry": 6}

连接字符串：joining

String joined = list.stream().collect(Collectors.joining(", "));
// 结果："apple, banana, cherry"

6. 示例代码

以下是一个完整的示例，展示 Stream 的常见用法：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry", "date");

        // 过滤、映射、排序、收集
        List<String> result = list.stream()
                                  .filter(s -> s.length() > 4) // 过滤长度大于 4 的字符串
                                  .map(String::toUpperCase)    // 转换为大写
                                  .sorted()                   // 排序
                                  .collect(Collectors.toList()); // 收集为列表

        System.out.println(result); // 输出：[APPLE, BANANA, CHERRY]
    }
}

总结

• Stream 提供了一种高效、简洁的方式来处理集合数据。
• 中间操作（如 filter、map）是惰性的，只有在终端操作（如 collect、forEach）调用时才会执行。
• 并行流可以充分利用多核 CPU 的性能。