Java Stream 流的常见用法和场景，以及注意事项

已于 2025-03-13 16:48:19 修改
阅读量899 收藏 7
点赞数 17
文章标签： java windows
于 2025-03-13 16:46:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38566870/article/details/146235550
版权
一、Stream 流的概述

Java Stream 是 Java 8 引入的一个重要的功能，它允许你以声明性的方式对集合或其他数据源进行操作。Stream 流提供了一种高效、易读且功能强大的方式来处理数据集合，支持顺序和并行两种处理方式。

二、Stream 流的常见用法
1. 创建 Stream 流
// 从集合创建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

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

// 使用静态方法 Stream.of()
Stream<String> streamOf = Stream.of("a", "b", "c");
2. 筛选过滤
// filter() 方法用于筛选符合条件的元素
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());
// evenNumbers 结果为 [2, 4, 6]
3. 映射转换
// map() 方法用于将流中的元素映射为另一种类型
List<String> words = Arrays.asList("hello", "world", "java");
List<Integer> lengths = words.stream()
    .map(String::length)
    .collect(Collectors.toList());
// lengths 结果为 [5, 5, 4]
4. 聚合操作
// 使用 reduce() 进行聚合操作
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
    .reduce(0, (a, b) -> a + b);
// sum 结果为 15

// 使用收集器 Collectors 进行聚合
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
    .collect(Collectors.summingInt(n -> n));
// sum 结果为 15
5. 排序
// sorted() 方法对流中的元素进行排序
List<Integer> numbers = Arrays.asList(5, 3, 2, 4, 1);
List<Integer> sortedNumbers = numbers.stream()
    .sorted()
    .collect(Collectors.toList());
// sortedNumbers 结果为 [1, 2, 3, 4, 5]

// 自定义排序
List<String> words = Arrays.asList("banana", "apple", "orange");
List<String> sortedWords = words.stream()
    .sorted((a, b) -> a.length() - b.length())
    .collect(Collectors.toList());
// sortedWords 结果为 ["apple", "banana", "orange"]
6. 去重
// distinct() 方法用于去除重复的元素
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4);
List<Integer> uniqueNumbers = numbers.stream()
    .distinct()
    .collect(Collectors.toList());
// uniqueNumbers 结果为 [1, 2, 3, 4]
7. 限制和跳过
// limit() 方法限制流中元素的数量
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> limitedNumbers = numbers.stream()
    .limit(3)
    .collect(Collectors.toList());
// limitedNumbers 结果为 [1, 2, 3]

// skip() 方法跳过流中的前 n 个元素
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> skippedNumbers = numbers.stream()
    .skip(2)
    .collect(Collectors.toList());
// skippedNumbers 结果为 [3, 4, 5]
8. 匹配和查找
// anyMatch() 检查是否至少有一个元素符合给定的条件
List<String> words = Arrays.asList("hello", "world", "java");
boolean hasLongWord = words.stream()
    .anyMatch(word -> word.length() > 5);
// hasLongWord 结果为 true

// allMatch() 检查所有元素是否都符合给定的条件
List<Integer> numbers = Arrays.asList(2, 4, 6, 8);
boolean allEven = numbers.stream()
    .allMatch(n -> n % 2 == 0);
// allEven 结果为 true

// noneMatch() 检查没有元素符合给定的条件
List<Integer> numbers = Arrays.asList(1, 3, 5, 7);
boolean noneEven = numbers.stream()
    .noneMatch(n -> n % 2 == 0);
// noneEven 结果为 true

// findFirst() 返回流中的第一个元素
List<String> words = Arrays.asList("hello", "world", "java");
Optional<String> firstWord = words.stream()
    .findFirst();
// firstWord 结果为 Optional["hello"]

// findAny() 返回流中的任意一个元素（在并行流中可能更高效）
List<String> words = Arrays.asList("hello", "world", "java");
Optional<String> anyWord = words.stream()
    .findAny();
// anyWord 结果可能为 Optional["hello"] 或其他元素
9. 流的扁平化
// flatMap() 将流中的每个元素映射为另一个流，然后将这些流连接成一个流
List<List<Integer>> listOfLists = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4),
    Arrays.asList(5, 6)
);
List<Integer> flatList = listOfLists.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList());
// flatList 结果为 [1, 2, 3, 4, 5, 6]
10. 转换为其他集合形式
// 转换为 List
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredList = numbers.stream()
    .map(n -> n * n)
    .collect(Collectors.toList());
// squaredList 结果为 [1, 4, 9, 16, 25]

// 转换为 Set
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4);
Set<Integer> uniqueSet = numbers.stream()
    .collect(Collectors.toSet());
// uniqueSet 结果为 {1, 2, 3, 4}

// 转换为 Map
List<String> words = Arrays.asList("hello", "world", "java");
Map<String, Integer> wordLengthMap = words.stream()
    .collect(Collectors.toMap(word -> word, word -> word.length()));
// wordLengthMap 结果为 {"hello"=5, "world"=5, "java"=4}
三、Stream 流的常见场景
1. 数据处理
// 计算员工工资总和
List<Employee> employees = Arrays.asList(
    new Employee("Alice", 5000),
    new Employee("Bob", 6000),
    new Employee("Charlie", 7000)
);
int totalSalary = employees.stream()
    .mapToInt(Employee::getSalary)
    .sum();
// totalSalary 结果为 18000
2. 集合操作优化
// 找出最长的单词
List<String> words = Arrays.asList("hello", "world", "java");
String longestWord = words.stream()
    .max((a, b) -> a.length() - b.length())
    .orElse("");
// longestWord 结果为 "hello"
3. 函数式编程实践
// 使用函数式接口对数字进行平方操作
Function<Integer, Integer> square = x -> x * x;
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredNumbers = numbers.stream()
    .map(square)
    .collect(Collectors.toList());
// squaredNumbers 结果为 [1, 4, 9, 16, 25]
四、Stream 流的注意事项
1. 避免在 Stream 操作中产生副作用
// 不推荐：在 Stream 操作中修改外部变量
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredList = new ArrayList<>();
numbers.stream()
    .forEach(n -> squaredList.add(n * n));
// squaredList 结果为 [1, 4, 9, 16, 25]

// 推荐：使用 map() 和 collect() 进行无副作用的操作
List<Integer> squaredList = numbers.stream()
    .map(n -> n * n)
    .collect(Collectors.toList());
2. 注意 Stream 的延迟执行特性
// Stream 操作是延迟执行的，只有在终止操作时才会真正执行
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream()
    .filter(n -> n % 2 == 0);
// 此时还没有执行过滤操作

List<Integer> evenNumbers = stream.collect(Collectors.toList());
// 此时才真正执行过滤操作
3. 处理异常和错误
// 在 Stream 操作中处理异常
List<String> words = Arrays.asList("hello", "world", "java");
List<Integer> lengths = words.stream()
    .map(word -> {
        try {
            return word.length();
        } catch (Exception e) {
            return 0;
        }
    })
    .collect(Collectors.toList());
4. 注意 Stream 的不可重复使用性
// Stream 只能使用一次，再次使用会抛出异常
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream();
stream.filter(n -> n % 2 == 0).collect(Collectors.toList());
// stream.filter(n -> n % 2 == 0).collect(Collectors.toList()); // 再次使用会抛出异常
5. 注意并行流的使用
// 并行流可以提高处理性能，但需要注意线程安全和顺序问题
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredList = numbers.parallelStream()
    .map(n -> n * n)
    .collect(Collectors.toList());
// squaredList 结果可能为 [1, 4, 9, 16, 25]，但顺序可能不保证
6. 避免过度使用 Stream
// 对于简单操作，传统的循环可能更高效
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 不推荐：过度使用 Stream
List<Integer> squaredList = numbers.stream()
    .map(n -> n * n)
    .collect(Collectors.toList());
// 推荐：对于简单操作，直接使用循环
List<Integer> squaredList = new ArrayList<>();
for (int n : numbers) {
    squaredList.add(n * n);
}
7. 注意空指针异常
// 在 Stream 操作中处理可能的空值
List<String> words = Arrays.asList("hello", null, "java");
List<String> nonNullWords = words.stream()
    .filter(Objects::nonNull)
    .collect(Collectors.toList());
// nonNullWords 结果为 ["hello", "java"]
8. 注意收集器的使用
// 使用收集器时注意线程安全和性能问题
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List<Integer>> partitionedMap = numbers.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));
// partitionedMap 结果为 {false=[1, 3, 5], true=[2, 4]}
9. 注意流的中间操作和终止操作
// 中间操作不会执行任何处理，直到遇到终止操作
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream()
    .filter(n -> n % 2 == 0);
// 此时还没有执行过滤操作

List<Integer> evenNumbers = stream.collect(Collectors.toList());
// 此时才真正执行过滤操作
10. 注意流的源数据不可变性
// Stream 操作不会修改源数据，除非显式地进行修改
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredList = numbers.stream()
    .map(n -> n * n)
    .collect(Collectors.toList());
// numbers 列表保持不变，squaredList 是新的列表

总结

Java Stream 流提供了一种高效、易读且功能强大的方式来处理数据集合。通过筛选过滤、映射转换、聚合操作、排序、去重、限制和跳过、匹配和查找、流的扁平化以及转换为其他集合形式等常见用法，可以方便地对数据进行各种操作。在实际应用中，需要注意避免副作用、处理异常、注意延迟执行特性、避免过度使用 Stream 等事项，以确保代码的正确性和高效性。

JAVA中的Stream流的使用详解
2302_79993788的博客
08-23 1327
下面我们来举个例子来感受一下Stream有多优雅Stream的类型我们可以对流进行中间操作或者终端操作。小伙伴们可能会疑问？
Java Stream流详解：从入门到精通
最新发布
qq_38955667的博客
05-11 1198
Stream流是Java 8引入的处理集合数据的API，它让我们以声明式（描述要做什么，而不是怎么做）的方式处理数据。核心特点声明式编程：更关注做什么，而不是怎么做支持链式操作：可以像搭积木一样组合多个操作支持并行处理：轻松切换到并行模式，提高性能延迟执行：在最后一步（终端操作）才会真正执行创建流：从数据源获取流中间操作：对流进行一系列转换和处理（延迟执行）终端操作：触发流的计算，返回结果中间操作：返回新Stream的操作，可以链式调用，不会立即执行。
Java中Stream流详解
welcome
08-27 5792
Java中的Stream是Java 8引入的一种新的API，用于处理集合或数组中的数据，提供了一种简洁且高效的方式来进行各种操作，如过滤、排序、映射、汇总等。Stream不存储数据，它更像是一个高级迭代器，通过一系列流水线操作来处理数据。中间操作和终端操作。
JAVA--流（Stream）的使用
m0_71678977的博客
04-07 1304
详细介绍了Stream流的使用方法以及步骤
【Java】java中stream流的各种用法汇总（适用于日常开发中对各种数据集的操作）
weixin_43219644的博客
10-15 855
日常开发中，我们经常会用到stream流操作数据集，stream流能够进行非常多的复杂操作，有时候我们并不能记住所有用法，好记性不如烂笔头，在这里给大家汇总常用的用法以及各种高级用法，帮助大家在项目中快速的开发实现业务逻辑，大家可以收藏并直接使用
Java 中 Stream 流的使用方法
qq_58417838的博客
12-25 2728
返回一个顺序流，即元素是按顺序处理的。这意味着对于大多数操作，它们将按照集合中元素的顺序依次执行。1.1、通过Collection对象的stream()或parallelStream()方法。1.4、通过IntStream、LongStream、DoubleStream接口中的of、1.3、通过Stream接口的of()、iterate()、generate()方法。使用一个终止操作来产生一个结果（新的对象）。该操作会强制之前的延迟操作立即执行，在此之后，该。操作是延迟执行的，会等到需要结果的时候才执行。
Java Stream流以及常用方法详解
愿你我都能实现自己的梦想
11-20 3818
Stream基本方法以及常用方法介绍
Java中Stream流的用法
2301_79957017的博客
01-08 1170
Strem流
java Stream流常用操作
qq_42320804的博客
05-28 1511
在Java 8中，Stream流是一种新的数据处理方式。Stream流并不是数据结构，它不会改变源数据，你可以视为遍历数据的高级迭代器。此外，Stream流可以透明地并行处理，无需我们在代码中手动进行并行处理。Stream流的操作可以分为两种：中间操作和终止操作。中间操作只对数据做标记，只有在遇到终止操作时才会进行实际的计算。在上面的代码中，filter是一个中间操作，forEach是一个终止操作。
Java Stream常见用法汇总，开发效率大幅提升
程序员小明1024
01-19 840
.markdown-body { line-height: 1.75; font-weight: 400; font-size: 16px; overflow-x: hidden; color: rgba(37, 41, 51, 1) } .markdown-body h1, .markdown-body h2, .markdown-body h3, .markdown-body h4, .ma...
Java Stream 流实现合并操作示例
08-19
今天，我们将详细介绍 Java Stream 流实现合并操作的原理、方法和注意事项。 Stream 流的合并 Stream 流的合并是指将两个或多个 Stream 流合并成一个流。这种操作的前提是元素的类型能够一致。 concat 方法 ...
Python-Java-Stream:适用于Python的Java流
03-04
Python-Java-Stream 提供了一些核心的类和方法，如 `Stream` 和一系列的静态方法，如 `stream()` 和 `of()`, 允许你创建和操作流。这些方法通常用于从列表、元组或其他迭代器生成流。例如： ```python from java_...
Java中的stream流
2202_75569688的博客
04-17 1306
在Java中，Stream流是Java 8引入的一种新的抽象概念，它允许对集合（Collection）对象进行函数式风格的操作。：Stream操作分为中间操作和终端操作两种类型，中间操作用于构建操作链，而终端操作会触发实际的计算。：虽然Stream提供了便利的操作方式，但在一些性能要求较高的场景下，可能需要考虑使用传统的迭代方式来替代Stream操作，以提高性能。：Stream操作不会修改原始数据，而是返回一个新的Stream，这样可以确保数据的不可变性，减少了并发环境下的问题。
JAVA-Stream流详解
分享，学习，专注，努力，向上。
07-02 3801
Stream（流）是Java 8引入的新特性，它是一种处理集合数据的高级抽象概念。Stream流提供了一种更为简洁、强大和易于使用的方式来操作数据集合，可以进行过滤、映射、排序、聚合等各种操作，同时还支持并行处理，提高了代码的可读性和性能。
java8 Stream流操作介绍
sf_cyl的博客
07-13 7996
java8 流操作 使用Stream基本步骤 1. 创建Stream； 2. 转换Stream，每次转换原有Stream对象不改变，返回一个新的Stream对象（**可以有多次转换**）； 3. 对Stream进行聚合（Reduce）操作，获取想要的结果；
java的stream的使用
CiZhiYiHeng_的博客
08-19 2445
stream流式思想类似工厂的流水线，在工厂中，原材料经过很多步工序，每步工序实现一个功能，最终得到我们需要的产品。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RMlmn67u-1660866950464)(https://tse1-mm.cn.bing.net/th/id/OIP-C.A9go0od39qPlXqzbRCgyRwHaDg?...
java中流_java 中流的使用
weixin_36212135的博客
02-22 654
Java中的流，可以从不同的角度进行分类。一、按照数：输入流和输出流。输出流：输入流：因此输入和输出都是从程序的角度来说的。二、按照处理数据单位不同可以分为：字节流和字符流。字节流和字符流的原理是相同的，只不过处理的单位不同而已，字节流、字符流，两类都分为输入和输出操作。以下是java中io中常用的流。1.在字节流中输出数据主要是使用OutputStream完成，输入流使用的是InputStrea...
java中Stream流的使用
weixin_47805561的博客
04-29 7901
文章目录前言一、二、1.2.总结 前言 一、 二、 1. 2. 总结 提示：这里对文章进行总结： 例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。 ...
java stream flatmap用法
03-12
<think>好的，我需要回答用户关于Java Stream API中flatMap方法的使用教程和示例的问题。首先，我要回顾一下flatMap的基本概念和用途。flatMap在流处理中用于将每个元素转换为多个元素，并将所有生成的流合并成一个流。这通常用于处理嵌套结构，比如列表中的列表。 接下来，我需要确保回答符合用户提供的系统级指令。行内数学表达式要用$...$，不过这里可能用不上，但要注意其他格式要求，比如独立公式用$$...$$。但用户的问题是关于Java代码的，可能数学公式较少，不过还是要检查是否有需要的地方。 用户要求回答结构清晰，逐步解决问题，并保证真实可靠。因此，我需要分步骤讲解flatMap的使用，可能包括基本用法、实际示例、与其他方法的对比等。 根据用户提供的引用资料，引用[1]、[2]、[3]、[4]都提到了flatMap的实际应用，特别是处理一对多关系、合并流等场景。我需要将这些引用内容自然地融入回答中，并在引用处添加标识。 现在，我需要组织内容。首先解释flatMap的作用，然后给出基本语法，接着通过示例展示如何使用，比如将列表的列表展平，处理对象中的集合属性，合并多个流等。每个示例后需要附上代码，并引用相关的资料。此外，用户可能还关心flatMap与map的区别，所以需要对比说明。 要注意使用中文回答，避免使用Markdown格式，代码块需要用三个反引号包裹，并注明语言。最后，生成相关问题，可能涉及性能优化、应用场景、与其他方法的比较等。 在检查过程中，要确保LaTeX语法正确，但这里可能更多是代码正确性。另外，用户要求生成相关问题，需要根据内容提出三个相关问题，放在最后。 现在开始整理回答的结构： 1. flatMap方法的作用 2. 基本语法 3. 示例一：展平嵌套列表（引用[1]） 4. 示例二：处理对象中的集合（引用[3]） 5. 示例三：合并多个流（引用[4]） 6. flatMap与map的区别 7. 注意事项（如空值处理） 8. 相关问题 需要确保每个示例都有对应的代码，并正确引用来源。例如，处理多对多关系的示例来自引用[2]和[3]，合并流的示例来自引用[4]。 最后，生成相关问题，例如性能影响、适用场景、并行流中的使用等。</think>### Java Stream `flatMap` 方法使用教程与示例 #### 1. `flatMap` 方法的作用 `flatMap` 是 Java Stream API 中用于 **“展平”流** 的核心方法。它将每个元素转换为一个流，并将所有生成的流合并为单个流。适用于处理嵌套集合（如 `List<List<T>>`）或多层数据结构，简化一对多关系的转换操作[^1][^2]。 #### 2. 基本语法 ```java <R> Stream<R> flatMap(Function<T, Stream<R>> mapper) ``` - **参数**：`mapper` 函数将每个元素 `T` 转换为一个 `Stream<R>`。 - **返回值**：合并后的新流 `Stream<R>`。 --- #### 3. 使用示例 ##### 示例1：展平嵌套列表（列表的列表 → 单列表） 将 `List<List<Integer>>` 转换为 `List<Integer>`： ```java List<List<Integer>> nestedList = Arrays.asList( Arrays.asList(1, 2), Arrays.asList(3, 4) ); List<Integer> flatList = nestedList.stream() .flatMap(Collection::stream) // 将每个子列表转为流并合并 .collect(Collectors.toList()); // 结果：[1, 2, 3, 4] ``` 此方法避免了多层循环，直接合并嵌套数据[^3]。 --- ##### 示例2：处理对象中的集合属性 假设有班级（`Class`）包含多个学生组（`Group`），需提取所有学生： ```java class Class { List<Group> groups; // getter } List<Class> classList = ...; List<Student> allStudents = classList.stream() .flatMap(c -> c.getGroups().stream()) // 将每个班级的组转为流 .flatMap(g -> g.getStudents().stream()) // 将每个组的学生转为流 .collect(Collectors.toList()); ``` 通过链式调用 `flatMap`，实现多层嵌套结构的展平[^3]。 --- ##### 示例3：合并多个流 将两个字符串数组合并为一个流，并分割单词： ```java List<String> list1 = Arrays.asList("Hello World", "Java Stream"); List<String> list2 = Arrays.asList("FlatMap Demo", "Example Code"); List<String> words = Stream.concat(list1.stream(), list2.stream()) .flatMap(s -> Arrays.stream(s.split(" "))) // 分割字符串并合并 .collect(Collectors.toList()); // 结果：[Hello, World, Java, Stream, FlatMap, Demo, Example, Code] ``` 此操作常用于多源数据的统一处理[^4]。 --- #### 4. `flatMap` 与 `map` 的区别 | 方法 | 输入 → 输出 | 用途 | |----------|-----------------------|--------------------------| | `map` | `T` → `R` | 一对一转换（如类型转换） | | `flatMap`| `T` → `Stream<R>` | 一对多转换并展平 | 例如： ```java // map 返回 Stream<List<String>> Stream<List<String>> mapped = nestedList.stream().map(List::stream); // flatMap 返回 Stream<String> Stream<String> flatMapped = nestedList.stream().flatMap(List::stream); ``` --- #### 5. 注意事项 - **空值处理**：若 `mapper` 返回 `null` 会导致 `NullPointerException`，建议使用空流替代： ```java .flatMap(x -> x != null ? x.stream() : Stream.empty()) ``` - **性能**：过度嵌套 `flatMap` 可能影响可读性和效率，需权衡结构复杂度。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值