19、Java 8 流 Stream ( 上 )

用 JDK 21 示例校正 filter 的保留条件、count 返回类型与惰性操作,区分 Java 8 API 范围。

简明结论

filter 保留 true,count 返回 long;Stream 不自动保证并行、原子性或性能收益。

filter 保留谓词返回 true 的元素。Stream 的中间操作是惰性的,通常需要终端操作触发计算;stream() 不表示自动并行,parallelStream() 也不保证更快。

完整可运行示例

本例在 JDK 21 执行。Stream 接口从 Java 8 开始提供,但下例使用的 List.of、Stream.toList 等 API 不全属于 Java 8;不能只看原标题就照搬到 Java 8 编译。需要 Java 8 时,应把集合创建与收集方式改为相应兼容 API 后重新验证。

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class StreamBasics {
  public static void main(String[] args) {
    var words = List.of("abc", "", "de", "");
    long empty = words.stream().filter(String::isEmpty).count();
    var kept = words.stream().filter(s -> !s.isEmpty()).toList();
    var squares = List.of(3, 2, 2, 3, 7, 3, 5).stream()
        .map(i -> i * i).distinct().toList();
    var calls = new AtomicInteger();
    var pipeline = words.stream().filter(s -> { calls.incrementAndGet(); return !s.isEmpty(); });
    if (calls.get() != 0) throw new AssertionError("Expected lazy intermediate operation");
    long count = pipeline.count();
    if (empty != 2 || count != 2 || !kept.equals(List.of("abc", "de"))
        || !squares.equals(List.of(9, 4, 49, 25))) throw new AssertionError();
    System.out.println("empty=2; kept=[abc, de]; squares=[9, 4, 49, 25]; lazy-before-terminal=true");
  }
}
javac StreamBasics.java
java StreamBasics

本次输出:

empty=2; kept=[abc, de]; squares=[9, 4, 49, 25]; lazy-before-terminal=true

语义边界

count() 返回 long。中间阶段的副作用可能被实现优化,不能把某次回调次数作为所有管道的执行保证;本例只断言终端操作前没有执行过滤,以及终端结果正确。并行流还需考虑共享状态、结合律、顺序和任务开销,本例没有并行性能测试。

下一步阅读

历史范例(未重建原环境)

以下保留旧资料的示例与输出,并校正语言标记和已发现的概念错误。含 MariaDB、旧 PHP/PDO、旧 Redis 或旧 JDK 语境的片段,本轮没有逐一运行;新实验的验证结论只适用于上方完整源码。不要把历史截图中的结果当作本轮输出。

流(Stream ) 是 Java 8 新增加的一个重磅级的功能。流是一个抽象层。有了流,我们就可以使用类似于 SQL 语句的声明方式来处理数据。

比如,下面的 SQL 语句

SELECT student_id, student_name, grade FROM Students
ORDER BY grade DESC, student_id LIMIT 1;

这条示意 SQL 按成绩和学号排序后取一行(并列处理需要业务规则),而全程,开发人员却不用直接面对任何计算和比较。

在流(Stream ) 出现之前,对于Java 中的集合框架的使用。开发人员不得不一次次的写一个循环,一次次的重复检查。当然了,这也什么,毕竟大家都是这样过来的。

更大的问题在于开发效率。面对当前的多核 CPU 计算机,面对并发编程。我们开发者常常会写出非常容易出错的并发执行的代码。

为了解决这些问题,Java 8 引入了流 ( Stream ) 这个概念,允许开发人员以声明的方式处理数据的同时,也可显式选择并行流;是否收益以及操作是否线程安全仍需评估。

流是什么 ?

Java 中的 流 ( Stream ) 表示来自 源 ( source ) 的一系列对象,它支持统计、求和、求平均值等聚合操作。

流具有以下特征:

  • 元素序列 : 流以顺序方式提供特定类型的一组元素。流只会按需获取/计算元素。但它从不存储元素。
  • 源 ( Source ):流可以将集合,数组或 I/O 资源作为输入源。
  • 聚合操作: 流支持聚合操作,如 filter、map、limit、reduce、find、match 等
  • 管道 ( pipelining ):大多数流操作都返回流本身,以便可以对其结果进行流水线操作。这些操作称为 中间 操作,它们的功能是获取输入,处理它们并将输出返回到目标。collect() 方法是一个终端操作,通常在流水线操作结束时出现,以标记流的结尾。
  • 内部迭代 ( Internal iteration ) : 与需要显式迭代的集合相比,流操作在内部对所提供的源元素进行迭代。

流的创建

Java 8 在推出流的同时,对集合框架也进行了一些比较大变更。主要是在 Collection 接口上提供了两种生成 Stream 的方法:

  • stream() 方法,该方法以集合作为源,返回集合中的所有元素以在集合中出现的顺序组成的流。
  • parallelStream() 方法,该方法以集合作为源,返回一个支持并发操作的流。

流支持的聚合操作

forEach() 方法

Java 8 为 Stream 提供了一种新方法 forEach(),用于迭代流的每个元素。

下面的代码片段演示了如何使用 forEach 打印 10 个随机数。

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

上面这个代码片段中,Random 对象的 ints() 方法会返回一个整数流。而 limit() 方法则限制了流中的元素个数。从某些方面说,可以理解为当源产生了 10 个随机数之后就关闭源。

map() 方法

map() 方法会迭代流中的元素,并为每个元素应用一个方法,然后返回应用后的流。

例如下面的代码,使用 map() 方法把求出每个元素的平方,然后过滤掉重复的元素,最后在转换为列表集合

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
//获取每个元素的平方
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

map( i -> i*i) 操作求取流中每个元素的平方,并返回一个新的流。distinct() 方法则用于过滤流中的重复元素。

filter() 方法

filter() 方法根据一个谓词来过滤元素。这个谓词是一个方法,以流中的每一个元素作为参数,返回 true 的元素会被保留,返回 false 的才会被过滤掉。

例如下面的代码,使用 filter() 方法过滤那些空字符串。

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
long count = strings.stream().filter(string -> string.isEmpty()).count();

后记

因为时间关系,这一章节先到这结束。