Java 8 Stream API 入门到实践详解

一、告别 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 实现多条件排序。

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

1. 流只能使用一次

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

2. 避免修改外部变量
   

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

3. 并行流未必更快

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

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