Java stream流的避坑指南

在使用Java Stream API时，虽然它提供了强大的功能来简化集合操作，但也存在一些常见的“坑”需要注意。以下是详细的避坑指南：

1. Stream的不可重用性

• 问题：Stream一旦被消费（如调用forEach、collect等终端操作），就不能再次使用。
• 解决方案：如果需要多次操作同一个数据源，可以重新创建Stream，或者将Stream的结果保存到集合中。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream();
stream.forEach(System.out::println); // 第一次消费
stream.forEach(System.out::println); // 抛出IllegalStateException

2. 并行流的线程安全问题

• 问题：并行流（parallelStream）在多线程环境下可能会引发线程安全问题，尤其是在共享可变状态时。
• 解决方案：避免在并行流中使用共享的可变状态，或者使用线程安全的集合（如ConcurrentHashMap）。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = new ArrayList<>();
numbers.parallelStream().forEach(result::add); // 线程不安全

3. Stream的延迟执行

• 问题：Stream的中间操作（如filter、map）是延迟执行的，只有在终端操作（如collect、forEach）调用时才会真正执行。
• 解决方案：确保在终端操作之前完成所有中间操作，避免在中间操作中引入副作用。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream().filter(n -> {
    System.out.println("Filtering: " + n);
    return n > 2;
}); // 不会立即执行
stream.forEach(System.out::println); // 执行过滤和输出

4. Stream的性能问题

• 问题：Stream的操作可能会带来额外的性能开销，尤其是在数据量较小的情况下。
• 解决方案：对于简单的操作，使用传统的循环可能更高效。对于大数据集，Stream的并行流可以提高性能。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 传统循环
for (int n : numbers) {
    if (n > 2) {
        System.out.println(n);
    }
}
// Stream
numbers.stream().filter(n -> n > 2).forEach(System.out::println);

5. Stream的空指针问题

• 问题：如果Stream的元素为null，可能会引发NullPointerException。
• 解决方案：在操作Stream之前，确保元素不为null，或者使用Optional来处理可能的null值。

List<String> list = Arrays.asList("a", "b", null, "c");
list.stream().filter(Objects::nonNull).forEach(System.out::println);

6. Stream的排序问题

• 问题：sorted操作可能会改变Stream的顺序，尤其是在并行流中。
• 解决方案：确保在排序操作之前完成所有中间操作，或者使用Comparator来明确排序规则。

List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);
numbers.stream().sorted().forEach(System.out::println); // 1, 2, 3, 4, 5

7. Stream的无限流问题

• 问题：Stream.generate和Stream.iterate可以创建无限流，如果不加以限制，可能会导致程序无法终止。
• 解决方案：使用limit来限制流的大小，或者使用takeWhile来在满足条件时终止流。

Stream.generate(Math::random).limit(10).forEach(System.out::println);

8. Stream的副作用

• 问题：在Stream操作中引入副作用（如修改外部变量）可能会导致不可预期的行为。
• 解决方案：尽量避免在Stream操作中引入副作用，使用纯函数式操作。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
numbers.stream().forEach(n -> sum += n); // 不推荐
int total = numbers.stream().reduce(0, Integer::sum); // 推荐

9. Stream的flatMap使用

• 问题：flatMap用于将多个流合并为一个流，但如果使用不当，可能会导致性能问题或逻辑错误。
• 解决方案：确保flatMap中的映射函数返回的是流，并且流的元素类型正确。

List<List<Integer>> nestedList = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4),
    Arrays.asList(5, 6)
);
List<Integer> flatList = nestedList.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList()); // [1, 2, 3, 4, 5, 6]

10. Stream的reduce操作

• 问题：reduce操作可能会因为初始值或累加器的使用不当而导致错误。
• 解决方案：确保初始值与累加器的类型匹配，并且累加器函数是结合性的。

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

总结

Java Stream API 提供了强大的功能，但也需要谨慎使用。理解Stream的特性和潜在问题，可以帮助我们避免常见的陷阱，编写出高效、安全的代码。