Java 流（Stream）API

原创已于 2025-05-16 17:00:37 修改

· 811 阅读

21 ·

版权

文章标签：

#python #windows #开发语言

于 2025-05-16 16:59:10 首次发布

一、理论说明

1. 流的定义

Java 流（Stream）是 Java 8 引入的新特性，用于对集合（如 List、Set）或数组进行高效的聚合操作（如过滤、映射、排序）和并行处理。流不存储数据，而是按需计算，支持链式调用，使代码更简洁、易读。

2. 流与集合的区别

特性	集合（Collection）	流（Stream）
数据存储	存储元素，占用内存	不存储数据，按需计算
遍历方式	外部迭代（手动 for/foreach）	内部迭代（自动处理）
一次性使用	可重复遍历	只能消费一次（类似迭代器）
延迟执行	立即执行	中间操作延迟，终止操作触发执行
并行支持	需要手动实现多线程	直接支持并行流（`parallelStream()`）

二、流的创建与操作

1. 创建流

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

public class StreamExample {
    public static void main(String[] args) {
        // 1. 从集合创建
        List<String> list = Arrays.asList("a", "b", "c");
        Stream<String> stream = list.stream();

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

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

        // 4. 创建无限流
        Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2);
        infiniteStream.limit(5).forEach(System.out::println); // 输出: 0, 2, 4, 6, 8
    }
}

2. 中间操作（返回新的流）

使用时需注意：流只能消费一次，消费后需重新创建。并行流适用于计算密集型任务，避免 I/O 操作。合理选择中间操作和终止操作，避免过度使用复杂流。流 API 是 Java 8 最具影响力的特性之一，广泛应用于数据处理、微服务、ORM 框架等场景。

过滤：filter(Predicate<T>)
映射：map(Function<T, R>)
排序：sorted() 或 sorted(Comparator<T>)
去重：distinct()
截断：limit(long maxSize)

跳过：skip(long n)

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
        .filter(n -> n % 2 == 0)    // 过滤偶数
        .distinct()                // 去重
        .sorted()                  // 排序
        .collect(Collectors.toList()); // [2, 4]

3. 终止操作（触发计算并关闭流）

聚合：count(), max(), min()
匹配：anyMatch(), allMatch(), noneMatch()
收集：collect(Collectors.toList()), toSet(), toMap()
归约：reduce()

遍历：forEach()

List<String> words = Arrays.asList("apple", "banana", "cherry");

// 计算总长度
int totalLength = words.stream()
        .mapToInt(String::length)
        .sum(); // 结果: 5 + 6 + 6 = 17

// 检查是否所有单词长度大于 3
boolean allLong = words.stream()
        .allMatch(w -> w.length() > 3); // true

三、并行流（Parallel Stream）

通过parallelStream()或stream().parallel()创建并行流，利用多线程加速处理（适用于大数据量）。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream()
        .mapToInt(Integer::intValue)
        .sum();

注意：并行流的线程安全问题，避免在流操作中修改共享状态。

四、Collectors 工具类

Collectors提供了丰富的收集器，用于将流结果转换为集合、Map 或进行分组统计。

1. 集合收集

List<String> names = people.stream()
        .map(Person::getName)
        .collect(Collectors.toList());

2. 分组统计

Map<Integer, List<Person>> ageGroups = people.stream()
        .collect(Collectors.groupingBy(Person::getAge));

3. 字符串连接

String joined = people.stream()
        .map(Person::getName)
        .collect(Collectors.joining(", ", "[", "]"));
// 结果: "[Alice, Bob, Charlie]"

五、应用实例

1. 筛选与映射

class Product {
    private String name;
    private double price;
    private Category category;

    // 构造方法、getter/setter 略
}

enum Category { FOOD, ELECTRONICS, CLOTHING }

// 统计电子产品的平均价格
List<Product> products = getProductList();
double avgPrice = products.stream()
        .filter(p -> p.getCategory() == Category.ELECTRONICS)
        .mapToDouble(Product::getPrice)
        .average()
        .orElse(0.0);

2. 分页处理

List<Product> page2 = products.stream()
        .skip(10)  // 跳过前10条
        .limit(10) // 取10条
        .collect(Collectors.toList());

六、自我总结

Java 流 API 提供了一种高效、优雅的方式处理集合数据，其核心优势包括：
代码简洁：链式调用减少冗余代码。
内部迭代：自动处理遍历逻辑，提升可读性。
并行支持：简化多线程编程，提升大数据处理性能。
延迟执行：避免不必要的计算，优化性能。
七、面试题

题目：

答案;