Java 8 Stream流：探索高效、简洁的数据处理之道

最新推荐文章于 2025-07-25 11:49:58 发布
原创 最新推荐文章于 2025-07-25 11:49:58 发布 · 1k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm #数据结构

一、Java 8 Stream流简介

在Java 8中，Stream API是一个新添加的功能，它允许在集合上进行更加高效且便捷的操作。Stream API利用内部迭代器，以函数式编程的方式对集合进行处理，可以显著地提高代码的可读性和简洁性。

1.1 什么是Stream流

1.1.1 Stream流的定义

Stream流是一个来自数据源（例如集合、数组、I/O通道等）的元素序列，并支持聚合操作，可以让我们非常方便地对数据进行操作和处理。Stream API提供了一种统一的处理流式数据的方式，使得我们可以在不同的数据集合上使用相同的语法进行处理。

Stream流提供了一种高效且易于使用的处理数据的方式，特别是对于大量数据的处理。Stream流不是数据结构，而是对数据的一种描述，它不会存储数据，也不会修改数据源。

1.1.2 Stream流与传统集合的区别
  • Stream流是一种数据流，不是数据结构，它不会存储数据。
  • Stream流操作是延迟执行的，只有当需要结果时才会执行。
  • Stream流可以进行并行处理，提高数据处理效率。
  • Stream流提供了丰富的函数式编程方法，使得代码更简洁、易读。

1.2 Stream流的来源

1.2.1 从集合创建Stream流

集合类（如List和Set）可以通过调用stream()方法创建一个Stream流。例如：

List<String> list = Arrays.asList("apple", "banana", "orange");
Stream<String> stream = list.stream();
1.2.2 从数组创建Stream流

可以使用Arrays.stream()方法从数组创建一个Stream流。例如：

String[] array = {
   
   "apple", "banana", "orange"};
Stream<String> stream = Arrays.stream(array);
1.2.3 从I/O通道创建Stream流

可以使用Files.lines()方法从文件中创建一个Stream流，每个元素代表文件中的一行。例如：

Path path = Paths.get("file.txt");
try (Stream<String> stream = Files.lines(path)) {
   
   
    stream.forEach(System.out::println);
} catch (IOException e) {
   
   
    e.printStackTrace();
}
1.2.4 其他Stream流创建方法

  • 使用Stream.of()方法创建一个包含多个元素的Stream流：

    Stream<String> stream = Stream.of("apple", "banana", "orange");

  • 使用Stream.iterate()方法创建一个无限Stream流：

    Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(10);

  • 使用Stream.generate()方法创建一个无限Stream流：

    Stream<Double> stream = Stream.generate(Math::random).limit(5);

注意：在使用无限Stream流时，通常需要使用limit()方法限制元素数量，以避免无限循环。

二、Stream流的操作

2.1 中间操作

2.1.1 filter过滤操作

filter方法接受一个Predicate类型的参数，用于过滤Stream中的元素，并返回符合条件的元素组成的新Stream。

/**
 * 过滤所有偶数并输出
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
numbers.stream()
    .filter(n -> n % 2 == 0)
    .forEach(System.out::println);

// 输出结果：
// 2
// 4
// 6
// 8
// 10
2.1.2 map映射操作

map方法接受一个Function类型的参数，用于将一个元素转换为另一个元素，并返回一个新的Stream。

/**
 * 转换所有数字为它们的平方，并输出
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
    .map(n -> n * n)
    .forEach(System.out::println);

// 输出结果：
// 1
// 4
// 9
// 16
// 25
2.1.3 flatMap扁平化操作

flatMap方法与map方法类似，不同之处在于flatMap方法的参数是一个函数，该函数将一个元素映射成一个Stream，最终将这些Stream合并成一个新的Stream。

/**
 * 将一个字符串数组分割成单词并输出
 */
String[] words = {"Hello", "World"};
Arrays.stream(words)
    .flatMap(s -> Stream.of(s.split("")))
    .forEach(System.out::println);

// 输出结果：
// H
// e
// l
// l
// o
// W
// o
// r
// l
// d
2.1.4 distinct去重操作

distinct方法会返回一个去除重复元素后的新Stream。

/**
 * 去掉重复数字并输出
 */
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 5, 5);
numbers.stream()
    .distinct()
    .forEach(System.out::println);

// 输出结果：
// 1
// 2
// 3
// 4
// 5
2.1.5 sorted排序操作

sorted方法接受一个可选的比较器，将Stream中的元素按照指定方式（默认为自然顺序）进行排序，返回一个新的Stream。

/**
 * 对数字列表进行排序后输出
 */
List<Integer> numbers = Arrays.asList(5, 4, 3, 2, 1);
numbers.stream()
    .sorted()
    .forEach(System.out::println);

// 输出结果：
// 1
// 2
// 3
// 4
// 5

可以通过传递一个比较器来指定排序方式：

/**
 * 对字符串列表以长度进行排序后输出
 */
List<String> words = Arrays.asList("apple", "banana", "pear", "orange");
words.stream()
    .sorted(Comparator.comparing(String::length))
    .forEach(System.out::println);

// 输出结果：
// pear
// apple
// banana
// orange
2.1.6 peek查看操作

peek方法接受一个Consumer类型的参数，可以在Stream中的每个元素执行所提供的操作，该方法不会影响Stream的元素。

/**
 * 查看数字是否大于3，并输出
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
    .peek(n -> System.out.print("value: " + n + ", "))
    .filter(n -> n > 3)
    .forEach(System.out::println);

// 输出结果：
// value: 1, value: 2, value: 3, value: 4, 4
// value: 5, 5
2.1.7 limit截取操作

limit方法用于截取Stream中指定数量的元素，返回一个新的Stream。

/**
 * 只输出前3个数字
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
    .limit(3)
    .forEach(System.out::println);

// 输出结果：
// 1
// 2
// 3

2.2 终止操作

2.2.1 forEach遍历操作

forEach方法接受一个Consumer类型的参数，对Stream中的每个元素执行所提供的操作。

/**
 * 输出数字的平方
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
    .map(n -> n * n)
    .forEach(System.out::println);

// 输出结果：
// 1
// 4
// 9
// 16
// 25
2.2.2 toArray转换为数组操作

toArray方法将Stream中的元素转换为一个数组。

/**
 * 将数字转换为数组
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer[] numberArray = numbers.stream().toArray(Integer[]::new);
for (Integer number : numberArray) {
    System.out.print(number + " ");
}

// 输出结果：
// 1 2 3 4 5
2.2.3 reduce规约操作

reduce方法用于将Stream中的所有元素结合成一个结果。它接受一个BinaryOperator类型的参数，该参数定义了对Stream中的元素进行连续计算的方式。

/**
 * 计算数字总和
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> result = numbers.stream().reduce((a, b) -> a + b);
result.ifPresent(System.out::println);

// 输出结果：
// 15
2.2.4 collect收集操作

collect方法将Stream中的元素收集到一个集合中。它接受一个Collector类型的参数，该参数定义了如何收集Stream中的元素。

/**
 * 将数字列表转换为Set并输出
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Set<Integer> numberSet = numbers.stream().collect(Collectors.toSet());
for (Integer number : numberSet) {
    System.out.print(number + " ");
}

// 输出结果：
// 1 2 3 4 5
2.2.5 min、max、count等聚合操作

min、max、count等方法都是求Stream中元素的一些统计信息。

/**
 * 求最大值、最小值和数量
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = numbers.stream().max(Integer::compare);
Optional<Integer> min = numbers.stream().min(Integer::compare);
long count = numbers.stream().count();

System.out.println("max: " + max.get() + ", min: " + min.get() + ", count: " + count);

// 输出结果：
// max: 5, min: 1, count: 5
2.2.6 anyMatch、allMatch、noneMatch等匹配操作

anyMatch、allMatch、noneMatch等方法用于判断Stream中的元素是否满足特定条件。

/**
 * 判断是否存在偶数
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean hasEvenNumber = numbers.stream().anyMatch(n -> n % 2 == 0);
System.out.println("Has even number: " + hasEvenNumber);

// 输出结果：
// Has even number: true
2.2.7 findFirst、findAny等查找操作

findFirst、findAny等方法用于返回Stream中的任意一个元素（如果存在）。

/**
 * 返回数字列表中的任意一个数字
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> anyNumber = numbers.stream().findAny();
anyNumber.ifPresent(System.out::println);

// 输出结果：
// 1 （注意输出结果可能与本例不一致）

三、Stream流的并行处理

3.1 并行Stream流简介

3.1.1 什么是并行Stream流

Java 8引入的Stream API，提供了一种新的处理集合数据的方式。 Java 8中提供了两种类型的Stream：

  • sequentialStream：适合在单个处理器上运行，它只能顺序地处理一个元素流；
  • parallelStream：适合于运行在多核处理器上，这样可以将单个流分成多个流进行并行处理。

并行Stream是对顺序Stream的扩展，可以提高大量数据的处理速度，从而增加程序的性能。

3.1.2 并行Stream流的优势

并行计算可以显著提高处理大量数据的效率和响应时间，特别是当需要大量计算或遍历操作时。

并行Stream流的另一个优势是不需要程序员编写额外的代码来进行多线程操作，因为Java会自动将Stream流转换为并行执行模式，并自动维护所有必要的线程池和同步操作等。

3.2 创建并行Stream流

3.2.1 从顺序Stream流创建并行Stream流

从顺序Stream流创建并行Stream非常容易，只需要使用parallel()方法即可将顺序流转换为并行流。

/**
 * 使用顺序流和并行流分别计算数字列表的求和结果
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum1 = numbers.stream().reduce(0, Integer::sum);
int sum2 = numbers.parallelStream().reduce(0, Integer::sum);
System.out.println("Sequential Stream Sum: " + sum1);
System.out.println("Parallel Stream Sum: " + sum2);

// 输出结果：
// Sequential Stream Sum: 15
// Parallel Stream Sum: 15
3.2.2 从集合创建并行Stream流

从集合创建并行Stream也非常容易，只需要使用parallelStream()方法即可创建并行Stream。

/**
 * 使用并行流打印所有元素
 */
List<String> words = Arrays.asList("Hello", "Stream", "API");
words.parallelStream()
    .forEach(System.out::println);

// 输出结果（可能不是完全一致的顺序）：
// API
// Stream
// Hello

3.3 并行Stream流的注意事项

3.3.1 线程安全问题

在使用并行Stream时，需要注意线程安全问题。避免多个线程共享相同的状态或数据，因为并行操作每个子任务执行可能在不同线程中，需要记得同步访问共享数据。

/**
 * 在并行流中使用共享变量，导致结果错误
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
AtomicInteger total = new AtomicInteger();
numbers.parallelStream()
    .forEach(n -> total.addAndGet(n));
System.out.println("Total: " + total);

// 输出结果：
// Total: 15 （错误）

在上面的示例中，AtomicInteger是线程安全的，因为它提供原子性操作，但是由于forEach()方法产生多个线程，因此每个线程都独立地对共享变量进行增量更新，从而导致计算错误。

解决该问题有两种方式：

  1. 避免使用可变共享变量；
  2. 使用线程安全的类或同步控制。
/**
 * 使用并行流计算数字总和
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream().reduce(0, Integer::sum);
System.out.println("Sum: " + sum);

// 输出结果：
// Sum: 15
3.3.2 有状态操作的影响

在并行操作中，比如求和操作需要将所有元素相加，是一种有状态的操作。这类操作需要进行更多的同步和数据移动，以便多个线程可以协作计算。

对于大量数据而言，这类消耗较小。但是处理小规模数据时，这会成为一个瓶颈，因为线程同步的开销可能比执行本身的花费更高。

/**
 * 并行计算数字集合中大于5的元素的总和
 */
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.parallelStream()
    .filter(n -> n > 5)
    .reduce(0, Integer::sum);
System.out.println("Sum: " + sum);

// 输出结果：
// Sum: 40
3.3.3 并行Stream流的性能考虑

并行Stream处理比较大的数据集可能会影响性能，因为多线程的开销可能会超过实际的计算时间。另外，在使用并行Stream时还要考虑到下面这些问题：

  1. 数据大小：通常情况下，数据越大，使用并行Stream的性能提升就越明显；
  2. 操作花费：当操作时间越长时，并行Stream的性能提升就越明显；
  3. 数据结构：在处理数据时考虑它们的数据结构，设置合适的数据结构能够提高并行操作的效率；
  4. 程序员熟悉度：程序员需要有足够熟练的技能才能正确地使用parallelStream()。

4.1 示例1：数据筛选与统计

假设有一个员工列表，每个员工有姓名、部门和薪水三个属性。现在需要对这个员工列表进行筛选和统计操作。具体要求如下：

  • 筛选出薪水大于5000的员工；
  • 按照部门对员工进行分组，并计算每个部门的平均薪水和员工数量；
  • 对符合条件的员工按照薪水从高到低进行排序；
  • 计算所有员工的平均薪水和最高薪水。
4.1.1 准备数据

首先，我们需要准备一组员工数据来模拟实际情况。假设我们有以下员工数据：

List<Employee> employees = Arrays.asList(
        new Employee("Alice", "Sales", 6000),
        new Employee("Bob", "Sales", 5000),
        new Employee("Charlie", "HR", 5500),
        new Employee("David", "HR", 6500),
        new Employee("Ella", "IT", 7500),
        new Employee("Frank", "IT", 7000),
        new Employee("Grace", "HR", 4500)
);

其中，Employee类的定义如下：

class Employee {
   
   
    private String name;
    private String department;
    private int salary;

    public Employee(String name, String department, int salary) {
   
   
        this.name = name;
        this.department = department;
        this.salary = salary;
    }

    // Getters and setters
}
4.1.2 筛选出符合条件的员工

使用filter()方法对员工列表进行筛选，只保留薪水大于5000的员工：

List<Employee> highPaidEmployees = employees.stream()
        .filter(e -> e.getSalary() > 5000)
        .collect(Collectors.toList());

System.out.println("高薪员工：");
highPaidEmployees.forEach(System.out::println);

输出结果为：

高薪员工：
Employee{
   
   name='Alice', department='Sales', salary=6000}
Employee{
   
   name='Charlie', department='HR', salary=5500}
Employee{
   
   name='David', department='HR', salary=6500}
Employee{
   
   name='Ella', department='IT', salary=7500}
Employee{
   
   name='Frank', department='IT', salary=7000}
4.1.3 对员工列表进行分组和聚合

使用groupingBy()方法对员工列表进行分组，并使用mapping()方法进行值的转换和计算操作。

Map<String, DoubleSummaryStatistics> statsByDepartment = employees
最低0.47元/天 解锁文章

200万优质内容无限畅学
Java8 新特性之Stream（七）-- Stream的reduce()详细用法
PUYALEI的博客
10-17 1068
如果Stream 是空的，也是Stream 的。调用一个函数来进行组合归并操作，当归并是。中合并多个小部分结果。
1、探索Java SE 8 Stream库：数据处理的新时代
convnet3designer的博客
05-14 20
本文深入介绍了Java SE 8中引入的Stream库，详细解析了其在数据处理中的应用。内容涵盖流的创建、过滤、映射、平铺映射等中间操作，以及归约、收集结果、Optional类型处理和分组分区等高级特性。通过丰富的示例代码和图表，帮助开发者高效地处理集合数据，写出更简洁优雅的代码。
Java8 流处理
cst_code的博客
04-25 472
记录Java8流处理 /* *author:cst *如有错误请指出 */ FlatMap() Stream.flatMap(Function super String, ? extends Stream extends String>> mapper) api: Returns a stream consisting of the results of replacing eac
Java Stream 流式操作：让数据处理更简洁高效
最新发布
m0_73884648的博客
07-25 752
本文全面介绍Java 8引入的Stream流式API，涵盖其核心概念和实际应用。Stream是支持连续聚合操作的元素序列，具有不存储数据、惰性执行、可并行处理等特性。文章详细讲解了创建Stream的四种方式（集合、数组、直接创建、无限流）、中间操作（过滤、映射、排序）和终端操作（聚合、收集、遍历）。特别强调了并行流的使用场景和注意事项，并提供了最佳实践建议：保持链式调用简洁、优先使用基本类型流、正确处理Optional等。Stream API通过声明式编程简化数据处理，使代码更简洁高效，特别适合现代Java
java8 流式处理
放弃很容易，坚持很难。
11-24 433
java8 流式处理
Java8中的流处理Stream API
njitzyd
12-20 231
1. 是什么 Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对 集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数 据库查询。也可以使用 Stream API 来并行执行操作。简而言之， Stream API 提供了一种高效且易于使用的处理数据的方式。 注意： Stream 自己不会存储元素。 Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。 Stream 操
Java8 Stream流式处理
qq_34249468的博客
07-03 359
Java8 Stream流式处理
探索Java 8的Stream API：数据流处理的新纪元
07-16
### 探索Java 8的Stream API：数据流处理的新纪元 #### Java语言概览 Java作为一种广泛应用的编程语言，自1995年由Sun Microsystems（现属于Oracle公司）首次发布以来，就以其强大的功能和灵活性赢得了全球开发者...
探索Java 8 Stream API：现代数据处理的新纪元
m0_73940426的博客
06-13 1035
Java 8的Stream API为开发者提供了一种声明式的数据处理方式，极大地提高了代码的可读性和可维护性，同时通过并行处理能力增强了程序的性能。掌握Stream API不仅是顺应Java发展趋势的必然要求，也是提高开发效率和个人技术栈的重要一步。随着函数式编程思想的普及，Stream无疑将成为每位Java程序员不可或缺的技能之一。
Java8 Stream API：从新手到大师，一文带你领略数据流的魅力！
赵KK的博客
03-11 2599
Stream API可以让你以一种声明式的方式处理数据集合。它支持并行操作，可以极大地提高数据处理的效率。Stream不是数据结构，而是一个可以进行聚合操作的数据集合视图。sorted方法用于对流中的元素进行排序。对于已经排序的数据，使用sorted可以避免不必要的排序操作。如果需要自定义排序规则，可以使用。// 自然排序// 逆序排序Java 8 Stream API的这些方法提供了丰富的数据处理能力，可以帮助你以更高效、更简洁的方式处理数据。
Java 8新特性之流处理
sout的博客
01-26 1131
Java 8新特性之流处理1.定义2.流操作2.1 中间操作2.2 终端操作3.中间操作3.1 筛选和切片3.1.1 用谓词筛选（filter方法）3.1.2 筛选各异的元素（distinct方法）3.1.3 截短流（limit方法）3.1.4 跳过元素（skip方法）3.2 映射3.2.1 map方法3.2.2 flapMap3.3 排序4.终端操作4.1 allMatch4.2 anyMatch4.3 findFirst、finfAny4.4 reduce4.5 收集 1.定义 简单定义就是，从支持数据
Java8实战 流处理stream
delete_you的博客
10-05 930
快速上手stream类相关方法API介绍与使用，详细介绍中间操作与终端操作的区别
Stream API：Java 8 中的数据流式处理指南
m0_53117341的博客
09-08 1158
Hello , 大家好 , 本篇文章给大家讲解的是 Java 8 中的 Stream 流 .在 Java 8 中 , 引入了 Streams API，它允许以声明式方式处理数据集合。Stream API 提供了一种高级迭代器，可以用来执行序列化操作，如筛选、转换、聚合等。它支持并行操作，可以利用多核处理器来加速数据处理。在日常开发过程中 , 使用 stream 流能够显著提升开发效率 , 极大提升生产力 , 非常推荐使用 .
Java 8 Stream API：从基础到高级，掌握流处理的艺术
单枪匹码
10-16 1752
Java 8 API 添加了一个新的抽象称为Stream（流），可以让你以一种声明的方式处理数据，这种风格将要处理的元素集合看做一种流，元素流在管道中传输，并在管道中间的节点上经过中间操作（intermediate operation）的处理（如：筛选，排序，聚合等），最后由最终操作（terminal operation）得到前面处理的结果。
Java8流处理
get and write
03-04 1148
Java8提供强大的stream处理api，来操作数据源，对数据进行一系列处理，数据操作的思路类似于数据库的SQL操作，编码简单，执行效率高。 如果获取stream？ // 通过集合来获取 List&amp;lt;Integer&amp;gt; integers = Arrays.asList(1,2,3); Stream&amp;lt;Integer&amp;gt; stream1 = integers.stream(); ...
java8的流处理
uncle_king的博客
12-29 1595
java8 Stream 流处理 map filter reduce
java8流式处理
jeason_chan_zju的博客
07-16 2600
流式处理简介 https://www.cnblogs.com/shenlanzhizun/p/6027042.html java8，即jdk1.8中新增的内容， 转换流 中间操作 终端操作
java8之Stream流处理
weixin_51821247的博客
06-11 889
Stream 流处理，首先要澄清的是 java8 中的 Stream 与 I/O 流 InputStream 和 OutputStream 是完全不同的概念。Stream 机制是针对集合迭代器的增强。流允许你用声明式的方式处理数据集合（通过查询语句来表达，而不是临时编写一个实现）。本文后半部分将拿 Stream 中查询语句与我们熟悉的 SQL 查询语句做一些类别，方便大家的理解和记忆。Stream 主要包括对象流和数值流两大类Stream.of(), Arrays.stream()
探索Java8的新特性：Lambda表达式与Stream流
Stream API是Java 8中处理集合的新的抽象层，它提供了一种高效且易于使用的处理数据的方式。Stream API允许你以声明式处理数据集合，支持顺序和并行操作。 Stream API主要包含三个部分： - Stream的生成：可以...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值