JavaStream用法全解析

Java Stream 的用法

Java Stream 是 Java 8 引入的一个功能强大的 API，用于处理集合数据。它支持函数式编程风格，提供了一种高效、声明式的方式处理数据。

创建 Stream

可以通过多种方式创建 Stream，包括从集合、数组、生成器或直接使用 Stream.of 方法。

java 复制代码

// 从集合创建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> streamFromList = list.stream();

// 从数组创建
String[] array = {"a", "b", "c"};
Stream<String> streamFromArray = Arrays.stream(array);

// 使用 Stream.of
Stream<String> streamOf = Stream.of("a", "b", "c");

中间操作

Stream 提供了一系列中间操作，用于对数据进行转换或过滤。这些操作是惰性的，只有在触发终端操作时才会执行。

java 复制代码

// 过滤
List<String> filtered = list.stream()
    .filter(s -> s.startsWith("a"))
    .collect(Collectors.toList());

// 映射
List<String> mapped = list.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// 排序
List<String> sorted = list.stream()
    .sorted()
    .collect(Collectors.toList());

终端操作

终端操作会触发流的处理，并产生结果或副作用。一旦执行终端操作，流就不能再被使用。

java 复制代码

// 收集为 List
List<String> collected = streamFromList.collect(Collectors.toList());

// 遍历
streamFromList.forEach(System.out::println);

// 匹配
boolean anyMatch = streamFromList.anyMatch(s -> s.startsWith("a"));

// 计数
long count = streamFromList.count();

并行流

Stream 支持并行处理，可以通过 parallelStream 或 parallel 方法启用。

java 复制代码

List<String> parallelProcessed = list.parallelStream()
    .filter(s -> s.startsWith("a"))
    .collect(Collectors.toList());

数值流

对于基本数据类型，Stream 提供了专门的数值流（IntStream、LongStream、DoubleStream），以避免装箱拆箱的开销。

java 复制代码

IntStream intStream = IntStream.range(1, 10);
int sum = intStream.sum();

示例代码

以下是一个完整的示例，展示了如何从列表创建流，进行过滤、映射和收集操作。

java 复制代码

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

public class StreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Jane", "Doe", "Sarah");

        // 过滤并转换为大写
        List<String> result = names.stream()
            .filter(name -> name.length() > 3)
            .map(String::toUpperCase)
            .collect(Collectors.toList());

        System.out.println(result); // 输出: [JOHN, JANE, SARAH]
    }
}

Stream API 提供了丰富的操作方法，能够简化集合数据的处理，提高代码的可读性和效率。

流操作的高阶函数

collect 与自定义收集器

利用 Collectors 类或实现 Collector 接口构建复杂聚合操作。例如分区、分组后二次计算：

java 复制代码

Map<Boolean, Long> partitioned = stream.collect(
    Collectors.partitioningBy(
        x -> x > 50,
        Collectors.counting()
    )
);

并行流优化策略

显式控制并行度

通过 ForkJoinPool 自定义线程池避免资源竞争：

java 复制代码

ForkJoinPool customPool = new ForkJoinPool(4);
customPool.submit(() -> 
    largeList.parallelStream().forEach(computeTask)
).get();

有状态中间操作

takeWhile/dropWhile 条件截断

基于谓词动态控制流元素（Java 9+）：

java 复制代码

List<Integer> result = stream
    .takeWhile(n -> n < 100)
    .dropWhile(n -> n % 2 == 0)
    .toList();

原始类型流特化

避免装箱开销

使用 IntStream、LongStream 等特化流处理数值计算：

java 复制代码

DoubleSummaryStatistics stats = IntStream.range(1, 100)
    .asDoubleStream()
    .summaryStatistics();

流构建技巧

生成器函数创建无限流

结合 limit 实现懒加载数据源：

java 复制代码

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

异常处理机制

包装受检异常

通过函数式接口处理可能抛出异常的操作：

java 复制代码

List<Path> validFiles = files.stream()
    .flatMap(f -> {
        try {
            return Stream.of(f.toRealPath());
        } catch (IOException e) {
            return Stream.empty();
        }
    }).toList();

性能监控与调试

插入诊断点

使用 peek 记录中间状态而不终止流：

java 复制代码

List<String> processed = stream
    .peek(e -> log.debug("Pre-filter: {}", e))
    .filter(s -> s.length() > 3)
    .peek(e -> log.debug("Post-filter: {}", e))
    .toList();