特性

说明

流式处理

数据从源头（集合、数组等）流经一系列操作，最终由终端操作触发执行。

延迟执行

中间操作（如 filter）不会立即执行，直到终端操作（如 collect）触发，减少冗余计算。

不可变性

流不修改原始数据，每次操作返回新流（类似集合的不可变视图）。

并行支持

通过 parallel() 方法自动利用多核 CPU，简化并行编程（需注意线程安全）。

函数式风格

操作参数为 Lambda 表达式或方法引用，避免命令式循环的 “如何做”，专注 “做什么”。

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

Stream<Integer> stream = numbers.stream(); // 串行流

Stream<Integer> parallelStream = numbers.parallelStream(); // 并行流

int[] array = {1, 2, 3};

IntStream stream = Arrays.stream(array);

// 无限流（需终端操作限制，如 limit）

Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2).limit(5); // 0, 2, 4, 6, 8

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

类型

作用

示例方法（附说明）

中间操作

对流进行转换，返回新流（延迟执行）

filter（过滤）、map（映射）、sorted（排序）、distinct（去重）、limit（截断）

终端操作

触发流的执行，返回结果或副作用

forEach（遍历）、collect（收集）、reduce（聚合）、count（计数）、anyMatch（条件匹配）

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

// 需求：过滤长度>3的名字，转大写，按字母倒序排序，收集为 List

List<String> result = names.stream()

.filter(name -> name.length() > 3) // 中间操作：过滤

.map(String::toUpperCase) // 中间操作：映射

.sorted(Comparator.reverseOrder()) // 中间操作：排序

.collect(Collectors.toList()); // 终端操作：收集（触发执行）

// 输出：[CHARLIE, DAVID]

List<Integer> evenNumbers = numbers.stream()

.filter(n -> n % 2 == 0)

.collect(Collectors.toList()); // [2, 4]

List<Integer> lengths = names.stream()

.map(String::length) // 映射为长度

.collect(Collectors.toList()); // [5, 3, 7, 5]

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

List<Integer> flat = nested.stream()

.flatMap(Collection::stream) // 展平为 [1,2,3,4]

.collect(Collectors.toList());

int sum = numbers.stream().reduce(0, Integer::sum); // 0+1+2+3+4+5=15

// 按长度分组：{3=[Bob], 5=[Alice, David], 7=[Charlie]}

Map<Integer, List<String>> groupByLength = names.stream()

.collect(Collectors.groupingBy(String::length));

long count = numbers.parallelStream()

.filter(n -> n > 1000)

.count(); // 并行统计

场景

传统循环（命令式）

Stream（声明式）

过滤偶数并求和

int sum = 0;for (int n : nums) { if (n%2==0) sum +=n;}

nums.stream().filter(n->n%2==0).reduce(0, Integer::sum)

代码行数

5 行

1 行（链式操作）

可读性

关注 “如何遍历”

关注 “做什么”（过滤 + 求和）

并行支持

需手动实现多线程

一行 parallel() 自动并行

List<Integer> list = new ArrayList<>();

numbers.stream().forEach(list::add); // 正确（无副作用，内部迭代）

Stream<Integer> stream = numbers.stream();

stream.count(); // 第一次终端操作，正常

stream.count(); // 报错：Stream has already been operated upon or closed