java中的stream代表什么流式编程stream的5个核心操作

尼克

发布时间：2025-06-23 21:30:03

270人浏览过

来源于php中文网

原创

java中stream的5个核心操作是过滤、映射、排序、规约、收集。1. 过滤（filter）用于筛选符合条件的元素；2. 映射（map）将元素转换为另一种形式；3. 排序（sorted）对元素进行自然或自定义排序；4. 规约（reduce）将元素聚合成一个结果；5. 收集（collect）将结果存储到集合等数据结构中。

java中的stream代表什么流式编程stream的5个核心操作

Java中的Stream，简单来说，它不是一种数据结构，而是一种处理数据的方式。你可以把它想象成工厂里的流水线，数据（比如一个List）就像原材料，经过流水线上的一系列操作（过滤、转换、收集等等），最终变成你想要的产品。流式编程的核心就是围绕这条“流水线”展开，让数据处理更加简洁、高效。

流式编程Stream的5个核心操作

什么是Stream，它和集合有什么区别？

Stream和集合（Collection）经常被放在一起比较，但它们本质上是不同的。集合是用来存储数据的，而Stream是用来处理数据的。集合关注的是数据的存储和组织，而Stream关注的是对数据的计算和转换。一个集合可以创建多个Stream，每个Stream都可以对集合中的数据进行不同的处理。

立即学习“Java免费学习笔记（深入）”；

举个例子，你有一个List names，你可以用它创建一个Stream，然后过滤掉长度小于5的字符串，再把剩下的字符串转换成大写，最后收集到一个新的List中。这个过程中，原始的names集合并没有改变，Stream只是提供了一种处理数据的方式。

Stream操作可以分为两种：中间操作（Intermediate Operations）和终端操作（Terminal Operations）。中间操作返回一个新的Stream，可以链式调用，而终端操作返回一个结果或者产生副作用，标志着Stream操作的结束。

Stream的5个核心操作具体指的是哪些？

过滤 (Filtering)：filter() 方法允许你根据指定的条件筛选出符合条件的元素。例如，你可以过滤掉集合中的空字符串或者负数。

List numbers = Arrays.asList(1, 2, 3, 4, 5, -1, -2);
List positiveNumbers = numbers.stream()
                                     .filter(n -> n > 0)
                                     .collect(Collectors.toList());
// positiveNumbers: [1, 2, 3, 4, 5]

映射 (Mapping)：map() 方法可以将Stream中的每个元素转换成另一种类型。例如，你可以将字符串列表转换成对应的长度列表。

List words = Arrays.asList("java", "stream", "api");
List wordLengths = words.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());
// wordLengths: [4, 6, 3]

排序 (Sorting)：sorted() 方法可以对Stream中的元素进行排序。你可以使用自然排序，也可以自定义排序规则。

List names = Arrays.asList("Charlie", "Alice", "Bob");
List sortedNames = names.stream()
                                .sorted() // 自然排序
                                .collect(Collectors.toList());
// sortedNames: [Alice, Bob, Charlie]

List sortedNamesByLength = names.stream()
                                       .sorted(Comparator.comparingInt(String::length)) // 按长度排序
                                       .collect(Collectors.toList());
// sortedNamesByLength: [Bob, Alice, Charlie]

规约 (Reduction)：reduce() 方法可以将Stream中的元素聚合成一个结果。例如，你可以计算列表中所有元素的总和。

List numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional sum = numbers.stream()
                               .reduce(Integer::sum); // 求和
// sum: Optional[15]

int product = numbers.stream()
                     .reduce(1, (a, b) -> a * b); // 求积，初始值为1
// product: 120

收集 (Collecting)：collect() 方法可以将Stream中的元素收集到不同的数据结构中，比如List、Set、Map等。

英特尔AI工具

英特尔AI与机器学习解决方案

下载

List names = Arrays.asList("Alice", "Bob", "Charlie", "Alice");
List distinctNames = names.stream()
                                  .distinct() // 去重
                                  .collect(Collectors.toList());
// distinctNames: [Alice, Bob, Charlie]

Map nameLengths = names.stream()
                                        .collect(Collectors.toMap(name -> name, String::length, (oldValue, newValue) -> oldValue)); // 转换成Map
// nameLengths: {Alice=5, Bob=3, Charlie=7}

如何避免Stream操作中的常见错误？

在使用Stream时，有一些常见的错误需要避免。

多次使用同一个Stream：Stream只能被消费一次。一旦终端操作被调用，Stream就关闭了。如果需要再次使用相同的数据，需要重新创建一个Stream。

Stream stream = Arrays.asList("a", "b", "c").stream();
stream.forEach(System.out::println); // OK
// stream.forEach(System.out::println); // 抛出异常：java.lang.IllegalStateException: stream has already been operated upon or closed

忘记终端操作：如果没有终端操作，Stream操作链不会执行。

Arrays.asList("a", "b", "c").stream().filter(s -> s.startsWith("a")); // 什么都不会发生

使用并行Stream时的数据竞争：并行Stream可以提高处理速度，但也可能导致数据竞争问题。要确保传递给并行Stream的操作是线程安全的。

List numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
numbers.parallelStream().forEach(n -> {
    // 错误示例：修改共享状态，可能导致数据竞争
    // numbers.set(n - 1, n * 2);
});

除了这5个核心操作，Stream还有哪些常用的操作？

除了上面提到的5个核心操作，Stream API还提供了很多其他有用的操作。

peek()：peek() 方法允许你在Stream的每个元素被处理之前执行一些操作，比如打印日志或者修改元素的状态。它主要用于调试和观察Stream的处理过程。

List names = Arrays.asList("Alice", "Bob", "Charlie");
List modifiedNames = names.stream()
                                  .peek(name -> System.out.println("Processing: " + name))
                                  .map(String::toUpperCase)
                                  .collect(Collectors.toList());
// 输出：
// Processing: Alice
// Processing: Bob
// Processing: Charlie
// modifiedNames: [ALICE, BOB, CHARLIE]

flatMap()：flatMap() 方法可以将Stream中的每个元素转换成一个Stream，然后将所有的Stream合并成一个Stream。它常用于处理嵌套集合。

List> nestedList = Arrays.asList(
        Arrays.asList("a", "b"),
        Arrays.asList("c", "d"),
        Arrays.asList("e", "f")
);
List flattenedList = nestedList.stream()
                                       .flatMap(Collection::stream)
                                       .collect(Collectors.toList());
// flattenedList: [a, b, c, d, e, f]

findFirst() 和 findAny()：findFirst() 方法返回Stream中的第一个元素，而 findAny() 方法返回Stream中的任意一个元素。它们通常与 filter() 方法一起使用。

List names = Arrays.asList("Alice", "Bob", "Charlie");
Optional firstEvenLengthName = names.stream()
                                             .filter(name -> name.length() % 2 == 0)
                                             .findFirst(); // 找到第一个长度为偶数的字符串
// firstEvenLengthName: Optional[Alice]

Optional anyEvenLengthName = names.parallelStream()
                                          .filter(name -> name.length() % 2 == 0)
                                          .findAny(); // 找到任意一个长度为偶数的字符串 (并行流，结果不确定)
// anyEvenLengthName: Optional[Alice] (也可能是 Bob 或 Charlie，取决于并行执行的顺序)