一、告别 for 循环！

传统痛点：
Java 8 之前，集合操作离不开冗长的 for 循环和匿名类。例如，过滤列表中的偶数：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evens = new ArrayList<>();
for (Integer num : list) {if (num % 2 == 0) evens.add(num);
}

Stream 救场：
一行代码搞定：

List<Integer> evens = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());

核心优势：

简洁：链式调用替代复杂循环。
高效：惰性计算（Lazy Evaluation），按需执行。
并行：一键切换并行处理，提升性能。

二、Stream 三大核心操作：过滤、映射、归约

1. 过滤（filter）：筛出想要的元素

作用：只保留符合条件的元素。
语法：filter(Predicate<T> predicate)
示例：筛选长度超过3的字符串

List<String> languages = Arrays.asList("Java", "Python", "C++", "Go");
List<String> filtered = languages.stream().filter(s -> s.length() > 3).collect(Collectors.toList());
// 结果: ["Java", "Python"]

底层逻辑：遍历流中每个元素，保留 predicate.test(element) 为 true 的元素。
注意：filter 是中间操作，返回新流，需配合终端操作（如 collect）才能执行。

2. 映射（map）：元素转换

作用：将元素转换为另一种形式。
语法：map(Function<? super T, ? extends R> mapper)
示例：将字符串转为大写

List<String> upperCase = languages.stream().map(String::toUpperCase).collect(Collectors.toList());
// 结果: ["JAVA", "PYTHON", "C++", "GO"]

进阶玩法：

扁平化嵌套集合：用 flatMap 展开多层结构

List<List<String>> nested = Arrays.asList(Arrays.asList("a", "b"),Arrays.asList("c", "d"));
List<String> flat = nested.stream().flatMap(Collection::stream).collect(Collectors.toList());
// 结果: ["a", "b", "c", "d"]

3. 归约（reduce）：聚合数值，合二为一

作用：将元素合并为一个值（如求和、拼接字符串）。
语法：reduce(T identity, BinaryOperator<T> accumulator)
示例：计算整数列表的总和

List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
int sum = numbers.stream().reduce(0, Integer::sum);
// 结果: 10

魔法细节：

identity 是初始值（如求和时设为 0）。
accumulator 定义如何合并元素（如 a + b）。

三、实战：从新手到封神的 3 个场景

场景1：统计文本中单词频率

String text = "java stream api is powerful and easy to use";
Map<String, Long> wordCount = Arrays.stream(text.split(" ")).collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
// 结果: {java=1, stream=1, api=1, ...}

关键点：

split(" ") 分割字符串为流。
groupingBy 按单词分组，counting 统计次数。

场景2：并行处理大数据（真香警告）

List<Integer> largeList = IntStream.range(0, 1000000).parallel() // 切换并行流.filter(x -> x % 2 == 0).boxed().collect(Collectors.toList());
System.out.println(largeList );

效率对比：

串行流处理100万数据：约500ms。
并行流处理：约100ms（8核CPU）。

场景3：多级排序（薪资+年龄）

class Employee {String name;int salary;int age;// constructor & getters
}List<Employee> sorted = employees.stream().sorted(Comparator.comparing(Employee::getSalary).thenComparing(Employee::getAge)).collect(Collectors.toList());
System.out.println(sorted);

技巧：链式 Comparator 实现多条件排序。

四、避坑指南：新手常踩的雷区

流只能使用一次

Stream<Integer> stream = numbers.stream();
stream.forEach(System.out::println); // 正常
stream.forEach(System.out::println); // 报错！流已关闭

避免修改外部变量

int count = 0;
numbers.stream().forEach(n -> count++); // 错误！并行流下可能出错

并行流未必更快
- 小数据量：串行更优（省去线程切换开销）。
- 大数据量+复杂操作：并行提速显著。

五、总结：Stream API 的江湖地位

操作	传统方式	Stream 写法	爽点
过滤偶数	`for` + `if`	`filter(x -> x%2==0)`	代码量减半
字符串转大写	循环+`toUpperCase`	`map(String::toUpperCase)`	一行搞定
统计总数	`for` 累加	`reduce(0, Integer::sum)`	函数式编程优雅度拉满