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

Java大师成长计划之第6天：Java流式API（Stream API）

news 来源：原创 2025/4/29 8:09:17

📢 友情提示：

本文由银河易创AI（https://ai.eaigx.com）平台gpt-4o-mini模型辅助创作完成，旨在提供灵感参考与技术分享，文中关键数据、代码与结论建议通过官方渠道验证。

在 Java 8 及之后的版本中，引入了一种全新的处理集合的方式——流式 API（Stream API）。流式 API 提供了一种高效、简洁且清晰的方法来处理集合数据，尤其是在进行复杂的数据操作时。通过函数式编程的方式，开发者能够以更直观的方式表达数据处理的逻辑。本文将深入探讨 Java 流式 API 的基本概念、常用操作以及一些高级操作技巧，帮助你掌握这一强大的工具。

一、什么是流（Stream）

在 Java 8 中，引入了流（Stream）这一概念，为集合处理提供了一种新的方式。流是一种对数据源（如集合、数组或I/O通道等）的抽象，它允许以声明性和函数式的方式对数据进行操作，而不是通过传统的命令式方法遍历和操作数据。流的设计理念是通过将数据处理的逻辑与数据的存储方式分离，使得处理过程更加灵活和高效。

1.1 流的定义

流是一种用于处理数据序列的工具，可以从数据源中生成并对其进行操作。流并不存储数据，而是以一种连贯的方式处理数据，通常涉及一系列操作，这些操作可以是对数据的过滤、转换、聚合等。通过流，可以以更直观和简洁的方式处理复杂的数据处理逻辑。

1.2 流的特性

流具有以下几个主要特性：

无存储：流并不存储数据。它只是描述了数据的计算过程，可以看作是数据的“管道”。数据源（如集合或数组）负责数据的存储。
惰性求值：流的操作是惰性求值的。即中间操作（如 filter、map）不会立即执行，而是在终止操作（如 forEach、collect）调用时才会进行实际计算。这种机制可以提高性能，避免不必要的计算。
功能性：流支持函数式编程，允许开发者以更简洁的方式处理数据。流操作通常是通过 lambda 表达式实现的，这使得代码更具可读性和可维护性。
管道化：流操作可以串联成一个管道，允许对数据进行多步处理。每个操作都返回一个新的流，从而支持链式调用，这样可以简化数据处理的逻辑。
并行处理：流支持并行操作。通过简单地将 stream() 替换为 parallelStream()，开发者可以轻松地利用多核处理器来提升性能。

1.3 流的类型

流可以分为以下几种类型：

顺序流：顺序流是默认的流类型，按照数据源中元素的顺序进行处理。顺序流适合于大多数常规数据处理操作，具有良好的可读性。
并行流：并行流允许在多个线程中同时处理数据，使得数据处理能够充分利用多核 CPU 的优势。使用并行流时，需要注意线程安全和数据一致性问题。
无限流：流可以生成无限的数据序列，例如使用 Stream.iterate() 或 Stream.generate() 方法创建的流。这类流通常与限制操作（如 limit()）一起使用，以避免运行时异常。

1.4 总结

流（Stream）是 Java 8 引入的一种强大工具，通过函数式编程的方式处理数据集合，使得数据操作更加简洁、灵活和高效。流的特点使其在处理大量数据时表现优异，并且支持并行处理，从而充分利用现代多核处理器的能力。在后续的学习中，掌握流的创建、基本操作和高级技巧将有助于提高开发效率和代码质量，使你在 Java 编程的道路上迈出更坚实的一步。

二、流的创建

在 Java 中，流（Stream）并不直接持有数据，而是通过数据源生成。流可以从多种数据源创建，包括集合、数组、I/O 通道等。流的创建方式多样，灵活性高，允许开发者根据需要选择合适的方法来获取流。以下是一些常用的流创建方式：

2.1 从集合创建流

我们可以通过 Java 集合框架（例如 List、Set 等）直接创建流。这是最常见的流创建方式。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;public class StreamFromCollection {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript");Stream<String> stream = languages.stream(); // 从集合创建流// 使用流进行操作stream.forEach(System.out::println); // 输出每种语言}
}

2.2 从数组创建流

Java 提供了 Arrays.stream() 方法来从数组创建流。该方法可以处理任意类型的数组，包含基本数据类型和对象数组。

import java.util.Arrays;
import java.util.stream.Stream;public class StreamFromArray {public static void main(String[] args) {String[] languages = {"Java", "Python", "JavaScript"};Stream<String> stream = Arrays.stream(languages); // 从数组创建流// 使用流进行操作stream.forEach(System.out::println); // 输出每种语言}
}

2.3 使用 `Stream.of()` 方法

Stream.of() 方法可以直接创建流，支持任意数量的元素。此方法非常适合于创建小型、明确的数据流。

import java.util.stream.Stream;public class StreamOfMethod {public static void main(String[] args) {Stream<String> stream = Stream.of("Java", "Python", "JavaScript"); // 使用 Stream.of 创建流// 使用流进行操作stream.forEach(System.out::println); // 输出每种语言}
}

2.4 创建无限流

Java 8 支持创建无限流，通常用于生成序列或执行某些惰性计算。无限流的常用方法有 Stream.iterate() 和 Stream.generate()。

2.4.1 使用 `Stream.iterate()`

Stream.iterate() 方法可以创建一个无限流，通过指定的起始值和一个生成下一个元素的函数。

import java.util.stream.Stream;public class InfiniteStreamIterate {public static void main(String[] args) {Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1); // 从 0 开始的无限流// 限制输出前 10 个元素infiniteStream.limit(10).forEach(System.out::println); // 输出：0 1 2 3 4 5 6 7 8 9}
}

2.4.2 使用 `Stream.generate()`

Stream.generate() 方法可以生成一个无限流，依赖于提供的 Supplier 接口来生成流中的元素。

import java.util.Random;
import java.util.stream.Stream;public class InfiniteStreamGenerate {public static void main(String[] args) {Stream<Double> randomStream = Stream.generate(Math::random); // 生成随机数的无限流// 限制输出前 5 个随机数randomStream.limit(5).forEach(System.out::println); // 输出 5 个随机数}
}

2.5 从文件创建流

Java 8 提供了 Files.lines() 方法，可以从文件中创建流。这在处理文件内容时尤为方便。

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;public class StreamFromFile {public static void main(String[] args) {try (Stream<String> lines = Files.lines(Paths.get("example.txt"))) { // 从文件创建流lines.forEach(System.out::println); // 输出文件中的每一行} catch (IOException e) {e.printStackTrace();}}
}

2.6 总结

流的创建为 Java 提供了一种灵活而强大的数据处理方式。通过各种方法，开发者可以方便地从集合、数组、文件等多种数据源创建流，以适应不同的应用场景。流的创建过程简单直观，使得后续的数据处理操作变得更加高效和易于理解。在实际开发中，灵活掌握流的创建方式，将有助于提升代码的可读性和执行效率。

三、流的基本操作

Java 流式 API 提供了多种方法来对流中的数据进行操作，这些操作可以分为两大类：中间操作和终止操作。中间操作是惰性执行的，即在流被消费之前不会立即处理数据。而终止操作则会触发流的处理过程，返回最终结果或执行某些动作。下面将详细介绍流的基本操作，包括过滤、转换、排序、去重等。

3.1 过滤（filter）

filter 方法用于根据给定的条件过滤流中的元素。通过传入一个谓词（Predicate），可以保留符合条件的元素，丢弃不符合条件的元素。

import java.util.Arrays;
import java.util.List;public class StreamFilterExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript", "C++");// 使用 filter 方法过滤出以 "J" 开头的语言List<String> filtered = languages.stream().filter(lang -> lang.startsWith("J")).collect(Collectors.toList());System.out.println(filtered); // 输出: [Java, JavaScript]}
}

3.2 转换（map）

map 方法用于将流中的每个元素转换为另一种形式。通过提供一个函数，可以对每个元素进行处理，并生成一个新的流。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class StreamMapExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript");// 使用 map 方法将语言转换为其长度List<Integer> lengths = languages.stream().map(String::length).collect(Collectors.toList());System.out.println(lengths); // 输出: [4, 6, 10]}
}

3.3 排序（sorted）

sorted 方法用于对流中的元素进行排序。可以使用自然顺序排序，也可以通过提供一个比较器（Comparator）来实现自定义排序。

import java.util.Arrays;
import java.util.List;public class StreamSortedExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript", "C++");// 使用 sorted 方法对语言进行排序List<String> sorted = languages.stream().sorted().collect(Collectors.toList());System.out.println(sorted); // 输出: [C++, Java, JavaScript, Python]}
}

3.4 去重（distinct）

distinct 方法用于去除流中的重复元素。可以有效地从流中提取唯一值。

import java.util.Arrays;
import java.util.List;public class StreamDistinctExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "Java", "C++", "Python");// 使用 distinct 方法去除重复元素List<String> distinct = languages.stream().distinct().collect(Collectors.toList());System.out.println(distinct); // 输出: [Java, Python, C++]}
}

3.5 限制（limit）

limit 方法用于限制流中元素的数量。可以通过指定最大数量来截取流的前几个元素。

import java.util.Arrays;
import java.util.List;public class StreamLimitExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript", "C++", "C#");// 使用 limit 方法限制输出前 3 个元素List<String> limited = languages.stream().limit(3).collect(Collectors.toList());System.out.println(limited); // 输出: [Java, Python, JavaScript]}
}

3.6 跳过（skip）

skip 方法用于跳过流中的前 N 个元素。与 limit 方法相反，用于选择流中后面的元素。

import java.util.Arrays;
import java.util.List;public class StreamSkipExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript", "C++", "C#");// 使用 skip 方法跳过前 2 个元素List<String> skipped = languages.stream().skip(2).collect(Collectors.toList());System.out.println(skipped); // 输出: [JavaScript, C++, C#]}
}

3.7 终止操作

3.7.1 forEach

forEach 方法是终止操作之一，用于对流中的每个元素执行指定的操作。它通常用于遍历流中的元素。

import java.util.Arrays;
import java.util.List;public class StreamForEachExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript");// 使用 forEach 方法打印每种语言languages.stream().forEach(System.out::println);}
}

3.7.2 收集（collect）

collect 方法也是一个重要的终止操作，它将流中的元素收集到集合中。常用的收集器包括 toList()、toSet() 和 toMap()。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class StreamCollectExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript");// 使用 collect 方法将流的元素收集到 List 中List<String> collected = languages.stream().collect(Collectors.toList());System.out.println(collected); // 输出: [Java, Python, JavaScript]}
}

3.8 归约（reduce）

reduce 方法用于将流中的元素归约为一个单一的值，通常用于求和、计算乘积等操作。

import java.util.Arrays;
import java.util.List;public class StreamReduceExample {public static void main(String[] args) {List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);// 使用 reduce 方法计算总和int sum = numbers.stream().reduce(0, Integer::sum);System.out.println(sum); // 输出: 15}
}

3.9 总结

流的基本操作如过滤、转换、排序、去重等，提供了强大而灵活的数据处理能力。通过组合使用这些操作，开发者可以以简洁、直观的方式处理数据集合，优化代码的可读性和可维护性。掌握流的基本操作是有效使用 Java 流式 API 的基础，在实际开发中能够帮助你构建高效、优雅的数据处理逻辑。随着对流操作的深入理解，开发者能够更好地应对复杂的数据处理需求，提高编程效率。

四、流的高级操作技巧

Java 的流式 API 不仅提供了基本的操作，还支持许多高级操作和技巧，这些操作能够极大地增强数据处理的灵活性和性能。通过合理运用这些高级操作，开发者可以简化代码、提高可读性，并优化性能。以下将介绍一些常用的流的高级操作技巧，包括并行流、归约操作、收集器的使用、分组和分区、连接字符串等。

4.1 并行流

并行流允许开发者利用多核处理器的优势，自动将流中的数据分成多个部分，并在多个线程上并行处理。这对于处理大量数据时，可以显著提高性能。使用并行流非常简单，只需将 stream() 方法替换为 parallelStream()。

import java.util.Arrays;
import java.util.List;public class ParallelStreamExample {public static void main(String[] args) {List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);// 使用并行流计算平方和int sumOfSquares = numbers.parallelStream().map(n -> n * n).reduce(0, Integer::sum);System.out.println("Sum of squares: " + sumOfSquares); // 输出: 385}
}

4.2 归约（reduce）

流的 reduce 方法非常灵活，可以用于多种聚合操作。开发者可以根据需要传递不同的二元操作符，实现复杂的计算逻辑。

import java.util.Arrays;
import java.util.List;public class ReduceExample {public static void main(String[] args) {List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);// 计算乘积int product = numbers.stream().reduce(1, (a, b) -> a * b);System.out.println("Product: " + product); // 输出: 120}
}

4.3 使用收集器（Collectors）

Collectors 工具类提供了许多强大的收集器，可以简化数据的收集和处理。以下是几个常用的收集器：

4.3.1 toMap

使用 toMap 可以将流中的元素收集到一个 Map 中。可以通过指定键和值的生成方式来自定义映射。

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;public class ToMapExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript");// 使用 toMap 将语言及其长度存储到 Map 中Map<String, Integer> lengthMap = languages.stream().collect(Collectors.toMap(lang -> lang, String::length));System.out.println(lengthMap); // 输出: {Java=4, Python=6, JavaScript=10}}
}

4.3.2 groupingBy

groupingBy 用于将流中的元素根据指定条件进行分组，返回一个 Map，其中键为分组条件，值为符合条件的元素列表。

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;public class GroupingByExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "JavaScript", "Python", "C++", "C#");// 根据语言的首字母进行分组Map<Character, List<String>> groupedByFirstLetter = languages.stream().collect(Collectors.groupingBy(lang -> lang.charAt(0)));System.out.println(groupedByFirstLetter); // 输出: {J=[Java, JavaScript], P=[Python], C=[C++, C#]}}
}

4.3.3 partitioningBy

partitioningBy 用于将流中的元素根据条件分为两个部分，返回一个 Map<Boolean, List<T>>，其中 true 部分的元素满足条件，false 部分的元素不满足条件。

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;public class PartitioningByExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "JavaScript", "Python", "C++", "C#");// 根据语言长度进行分区Map<Boolean, List<String>> partitionedByLength = languages.stream().collect(Collectors.partitioningBy(lang -> lang.length() > 4));System.out.println(partitionedByLength); // 输出: {false=[C++, C#], true=[Java, JavaScript, Python]}}
}

4.4 连接字符串（joining）

使用 joining 方法将流中的字符串连接成一个字符串。可以指定连接符、前缀和后缀。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class JoiningExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "Python", "JavaScript");// 使用 joining 将语言连接成一个字符串String result = languages.stream().collect(Collectors.joining(", ", "[", "]"));System.out.println(result); // 输出: [Java, Python, JavaScript]}
}

4.5 复杂数据处理的示例

通过组合使用流的各种操作，可以处理更复杂的数据处理需求。例如，统计每种语言的长度并分组统计。

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;public class ComplexProcessingExample {public static void main(String[] args) {List<String> languages = Arrays.asList("Java", "JavaScript", "Python", "C++", "C#");// 统计每种语言的长度并分组Map<Integer, List<String>> lengthGrouped = languages.stream().collect(Collectors.groupingBy(String::length));System.out.println(lengthGrouped); // 输出: {4=[Java, C++], 6=[Python, C#], 10=[JavaScript]}}
}

4.6 总结

流的高级操作技巧极大地扩展了 Java 流式 API 的能力，允许开发者以更灵活和高效的方式处理集合数据。通过理解并应用并行流、归约操作、收集器、分组和分区等技术，开发者可以编写出更简洁、优雅且性能优化的代码。掌握这些高级操作技巧将为解决复杂的数据处理问题提供有力支持，提升整体编程能力。在实际开发中，灵活运用这些技巧，能够显著提高工作效率，增强代码质量。

五、流的最佳实践

在使用 Java 流式 API 时，遵循一些最佳实践能够帮助开发者有效地编写高效、可读性强的代码。以下是一些流的最佳实践，涵盖了性能优化、代码风格以及流的使用场景等方面。

5.1 优化性能

选择合适的流类型：对于大规模数据处理，考虑使用并行流（parallelStream()）来利用多核处理器的优势。但要注意并行流并不总是比顺序流性能更好，特别是在小数据集或操作较简单时，可能会引入额外的线程开销。
避免使用状态：在流操作中，尽量避免使用外部可变状态。流的操作应该是无状态的，这样可以确保代码的可重用性和线程安全。例如，在 map 或 filter 操作中，尽量不要使用外部变量作为状态。
合理使用中间操作：中间操作是惰性求值的，只有在终止操作调用时才会执行。因此，可以在执行终止操作之前链式调用多个中间操作，以减少流的遍历次数。确保将过滤和映射操作放在尽早的地方，以减少后续操作的计算量。
使用短路操作：利用流的短路能力，例如 findFirst() 和 anyMatch()，可以在找到满足条件的元素后立即返回，从而避免不必要的计算。这对于大型数据集尤其有效。

5.2 提高代码可读性

保持流操作的链式调用：流的操作通常是链式调用的，通过将多个操作组合在一起，可以使数据处理的逻辑更加清晰。例如，将过滤、映射和收集操作组合在一起，而不是分开实现。
```
List<String> result = languages.stream().filter(lang -> lang.startsWith("J")).map(String::toUpperCase).collect(Collectors.toList());
```
使用命名变量：在处理复杂的流操作时，可以考虑将中间结果赋值给命名变量，以提高代码的可读性。这有助于让其他开发者（或未来的自己）更容易理解代码的意图。
```
Stream<String> filteredLanguages = languages.stream().filter(lang -> lang.length() > 3);
List<String> upperCaseLanguages = filteredLanguages.map(String::toUpperCase).collect(Collectors.toList());
```
编写文档和注释：对于复杂的流操作，适当的注释和文档可以帮助解释代码的意图和实现方式，提升代码的可维护性。

5.3 理解流的生命周期

对流的限制：流只能被消费一次，一旦终止操作执行后，流就处于关闭状态，无法再次使用。如果需要再次处理相同的数据源，必须重新创建流。

资源管理：在处理 I/O 操作时（如从文件中读取数据），务必使用 try-with-resources 语句来确保流的正确关闭。例如：

try (Stream<String> lines = Files.lines(Paths.get("example.txt"))) {lines.forEach(System.out::println);
} catch (IOException e) {e.printStackTrace();
}