当前位置：首页 > article >正文

如何理解java中Stream流？

article 2025/3/25 9:20:53

在Java中，Stream 是 Java 8 引入的一个强大API，用于处理集合（如 List、Set、Map 等）数据的流式操作。它提供了一种声明式、函数式的编程风格，可以高效地进行过滤、映射、排序、聚合等操作。

Stream 的核心概念

流（Stream）：
- 流是一个来自数据源（如集合、数组、I/O 资源）的元素序列。
- 流本身不存储数据，而是按需计算。
- 流操作分为中间操作（Intermediate Operations）和终端操作（Terminal Operations）。
中间操作（Intermediate Operations）：
- 中间操作会返回一个新的流，可以链式调用。
- 常见的中间操作：filter()、map()、sorted()、distinct()、limit() 等。
- 中间操作是惰性的，只有在终端操作触发时才会执行。
终端操作（Terminal Operations）：
- 终端操作会触发流的执行，并产生一个结果或副作用。
- 常见的终端操作：forEach()、collect()、reduce()、count()、anyMatch() 等。
- 终端操作执行后，流会被消耗，无法再次使用。

Stream 的特点

声明式编程：
- 通过方法链描述操作，代码更简洁易读。
- 例如：list.stream().filter(...).map(...).collect(...)。
惰性求值：
- 中间操作不会立即执行，只有在终端操作触发时才会计算。
并行处理：
- 可以通过 parallelStream() 轻松实现并行处理，充分利用多核CPU。
不可复用：
- 流一旦被终端操作消费，就不能再次使用。

Stream 的常见操作

1. 创建流

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream(); // 从集合创建流
Stream<String> parallelStream = list.parallelStream(); // 创建并行流
Stream<Integer> numbers = Stream.of(1, 2, 3); // 直接创建流

2. 中间操作

过滤：filter()

List<String> result = list.stream()
                          .filter(s -> s.startsWith("a")) // 过滤以 "a" 开头的元素
                          .collect(Collectors.toList());

映射：map()

List<Integer> lengths = list.stream()
                            .map(String::length) // 将字符串映射为长度
                            .collect(Collectors.toList());

去重：distinct()

List<String> unique = list.stream()
                          .distinct() // 去重
                          .collect(Collectors.toList());

排序：sorted()

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

限制：limit()

List<String> firstTwo = list.stream()
                            .limit(2) // 只取前两个元素
                            .collect(Collectors.toList());

3. 终端操作

遍历：forEach()

list.stream().forEach(System.out::println); // 打印每个元素

收集：collect()

List<String> result = list.stream()
                          .filter(s -> s.length() > 1)
                          .collect(Collectors.toList()); // 收集为List

聚合：reduce()

Optional<String> combined = list.stream()
                                .reduce((s1, s2) -> s1 + "-" + s2); // 拼接字符串

匹配：anyMatch()、allMatch()、noneMatch()

boolean hasA = list.stream().anyMatch(s -> s.contains("a")); // 是否有包含 "a" 的元素

计数：count()

long count = list.stream().filter(s -> s.length() > 1).count(); // 统计符合条件的元素数量

并行流

通过 parallelStream() 可以轻松实现并行处理：

List<String> result = list.parallelStream()
                          .filter(s -> s.length() > 1)
                          .collect(Collectors.toList());