【Java 基础篇】Java Stream 流详解

原文地址：https://blog.51cto.com/techfanyi/7716839

Java Stream（流）是Java 8引入的一个强大的新特性，用于处理集合数据。它提供了一种更简洁、更灵活的方式来操作数据，可以大大提高代码的可读性和可维护性。本文将详细介绍Java Stream流的概念、用法和一些常见操作。

什么是Stream流？
在开始介绍Java Stream流之前，让我们先了解一下什么是流。流是一系列元素的序列，它可以在一次遍历的过程中逐个处理这些元素。在Java中，流是对数据的抽象，可以操作各种不同类型的数据源，如集合、数组、文件等。

Stream流的主要特点包括：

链式调用：可以通过一系列的方法调用来定义对流的操作，使代码更具可读性。
惰性求值：流上的操作不会立即执行，只有在遇到终端操作时才会触发计算。
函数式编程：流操作使用了函数式编程的思想，可以通过Lambda表达式来定义操作。
并行处理：可以轻松地将流操作并行化，充分利用多核处理器的性能。
创建Stream流
在使用Java Stream流之前，首先需要创建一个流。流可以从各种数据源中创建，包括集合、数组、文件等。

从集合创建流
可以使用集合的stream()方法来创建一个流。例如：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
Stream<String> stream = names.stream();
1.
2.
从数组创建流
可以使用Arrays.stream()方法来从数组中创建一个流。例如：

int[] numbers = {1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(numbers);
1.
2.
从文件创建流
可以使用Files.lines()方法来从文件中创建一个流。例如：

try (Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {
// 处理文件中的每一行数据
lines.forEach(System.out::println);
} catch (IOException e) {
e.printStackTrace();
}
1.
2.
3.
4.
5.
6.
流的操作
一旦创建了流，就可以对其进行各种操作。流的操作可以分为两类：中间操作和终端操作。

中间操作
中间操作是对流的一系列处理步骤，这些步骤会返回一个新的流，允许链式调用。中间操作通常用于对数据进行过滤、映射、排序等操作。一些常见的中间操作包括：

filter(Predicate<T> predicate)：根据条件过滤元素。
map(Function<T, R> mapper)：将元素映射为新的值。
sorted()：对元素进行排序。
distinct()：去重，去除重复的元素。
limit(long maxSize)：限制流中元素的数量。
skip(long n)：跳过流中的前n个元素。
例如，以下代码将对一个整数集合进行筛选、映射和排序操作：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> result = numbers.stream()
.filter(n -> n % 2 == 0) // 过滤偶数
.map(n -> n * 2) // 映射为原来的2倍
.sorted() // 排序
.collect(Collectors.toList()); // 收集结果
1.
2.
3.
4.
5.
6.
终端操作
终端操作是流的最后一步操作，它会触发对流的计算并产生一个最终的结果。终端操作通常包括：

forEach(Consumer<T> action)：对流中的每个元素执行操作。
collect(Collector<T, A, R> collector)：将流中的元素收集到一个容器中。
toArray()：将流中的元素收集到数组中。
reduce(identity, accumulator)：对流中的元素进行归约操作，返回一个值。
count()：返回流中元素的数量。
min(comparator)：返回流中的最小元素。
max(comparator)：返回流中的最大元素。
allMatch(predicate)：检查流中的所有元素是否都满足条件。
anyMatch(predicate)：检查流中是否存在满足条件的元素。
noneMatch(predicate)：检查流中是否没有元素满足条件。
findFirst()：返回流中的第一个元素。
findAny()：返回流中的任意一个元素。
终端操作是流的最后一步，一旦调用终端操作，流将被消耗，不能再被复用。

示例：从集合中筛选特定条件的元素
让我们通过一个示例来演示Java Stream流的使用。假设我们有一个包含学生对象的集合，每个学生对象都有姓名、年龄和成绩属性。我们想从集合中筛选出年龄大于18岁且成绩优秀的学生。

class Student {
private String name;
private int age;
private double score;

public Student(String name, int age, double score) {
this.name = name;
this.age = age;
this.score = score;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}

public double getScore() {
return score;
}

@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}

public class Main {
public static void main(String[] args) {
List<Student> students = Arrays.asList(
new Student("Alice", 20, 90.0),
new Student("Bob", 22, 85.5),
new Student("Charlie", 19, 88.5),
new Student("David", 21, 92.0),
new Student("Eva", 18, 94.5)
);

List<Student> result = students.stream()
.filter(student -> student.getAge() > 18 && student.getScore() >= 90.0)
.collect(Collectors.toList());

result.forEach(System.out::println);
}
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
运行以上代码，将输出符合条件的学生信息：

Student{name='Alice', age=20, score=90.0}
Student{name='David', age=21, score=92.0}
1.
2.
并行流
Java Stream还提供了并行流的支持，可以充分利用多核处理器的性能。只需将普通流转换为并行流，即可实现并行化处理。

List<Student> result = students.parallelStream()
.filter(student -> student.getAge() > 18 && student.getScore() >= 90.0)
.collect(Collectors.toList());
1.
2.
3.
需要注意的是，并行流在某些情况下可能会引发线程安全问题，因此在处理共享状态时要格外小心。

更多操作
当使用Java Stream流进行数据处理时，除了基本的过滤、映射、排序和归约等操作外，还有许多其他有用的中间操作和终端操作。在本节中，我将介绍一些常见的Stream流操作，帮助你更好地理解如何使用它们。

中间操作
1. distinct()
distinct()方法用于去除流中的重复元素，返回一个去重后的新流。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List<Integer> distinctNumbers = numbers.stream()
.distinct()
.collect(Collectors.toList());

System.out.println(distinctNumbers); // 输出: [1, 2, 3, 4, 5]
1.
2.
3.
4.
5.
6.
2. limit(n)
limit(n)方法用于截取流中的前n个元素，返回一个包含前n个元素的新流。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> limitedNumbers = numbers.stream()
.limit(5)
.collect(Collectors.toList());

System.out.println(limitedNumbers); // 输出: [1, 2, 3, 4, 5]
1.
2.
3.
4.
5.
6.
3. skip(n)
skip(n)方法用于跳过流中的前n个元素，返回一个跳过前n个元素后的新流。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> skippedNumbers = numbers.stream()
.skip(5)
.collect(Collectors.toList());

System.out.println(skippedNumbers); // 输出: [6, 7, 8, 9, 10]
1.
2.
3.
4.
5.
6.
4. flatMap()
flatMap()方法用于将流中的每个元素映射成一个新的流，然后将这些新流合并成一个流。通常用于将嵌套的集合扁平化。

示例：

List<List<Integer>> nestedLists = Arrays.asList(
Arrays.asList(1, 2),
Arrays.asList(3, 4),
Arrays.asList(5, 6)
);

List<Integer> flattenedList = nestedLists.stream()
.flatMap(Collection::stream)
.collect(Collectors.toList());

System.out.println(flattenedList); // 输出: [1, 2, 3, 4, 5, 6]
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
终端操作
1. forEach()
forEach()方法用于对流中的每个元素执行指定的操作。

示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
.forEach(name -> System.out.println("Hello, " + name));
1.
2.
3.
2. toArray()
toArray()方法用于将流中的元素收集到数组中。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer[] numberArray = numbers.stream()
.toArray(Integer[]::new);
1.
2.
3.
3. reduce(identity, accumulator)
reduce()方法用于对流中的元素进行归约操作，返回一个值。identity是初始值，accumulator是归约函数。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.reduce(0, (a, b) -> a + b);

System.out.println(sum); // 输出: 15
1.
2.
3.
4.
5.
4. collect()
collect()方法用于将流中的元素收集到一个集合或其他数据结构中。可以使用Collectors类提供的各种工厂方法创建不同类型的集合。

示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> collectedNames = names.stream()
.collect(Collectors.toList());

Set<String> collectedSet = names.stream()
.collect(Collectors.toSet());

Map<String, Integer> collectedMap = names.stream()
.collect(Collectors.toMap(name -> name, String::length));
1.
2.
3.
4.
5.
6.
7.
8.
9.
5. min(comparator) 和 max(comparator)
min(comparator)和max(comparator)方法用于查找流中的最小和最大元素，需要传入一个比较器（Comparator）来定义比较规则。

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> minNumber = numbers.stream()
.min(Integer::compareTo);

Optional<Integer> maxNumber = numbers.stream()
.max(Integer::compareTo);

System.out.println(minNumber.orElse(0)); // 输出: 1
System.out.println(maxNumber.orElse(0)); // 输出: 5
1.
2.
3.
4.
5.
6.
7.
8.
9.
6. anyMatch(predicate)、allMatch(predicate) 和 noneMatch(predicate)
这些方法用于检查流中的元素是否满足给定的条件。

anyMatch(predicate)：检查流中是否有任意一个元素满足条件。
allMatch(predicate)：检查流中的所有元素是否都满足条件。
noneMatch(predicate)：检查流中是否没有元素满足条件。
示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean anyGreaterThanThree = numbers.stream()
.anyMatch(n -> n > 3);

boolean allGreaterThanThree = numbers.stream()
.allMatch(n -> n > 3);

boolean noneGreaterThanTen = numbers.stream()
.noneMatch(n -> n > 10);

System.out.println(anyGreaterThanThree); // 输出: true
System.out.println(allGreaterThanThree); // 输出: false
System.out.println(noneGreaterThanTen); // 输出: true
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
7. findFirst() 和 findAny()
findFirst()方法返回流中的第一个元素（在串行流中通常是第一个元素，但在并行流中不确定），findAny()方法返回流中的任意一个元素。

示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Optional<String> first = names.stream()
.findFirst();

Optional<String> any = names.parallelStream()
.findAny();
1.
2.
3.
4.
5.
6.
这些只是Java Stream流的一些常见操作，Stream API提供了更多的方法来处理数据。根据具体的需求，你可以组合这些操作来构建复杂的数据处理流程。希望这些示例能帮助你更好地理解和使用Java Stream流。

注意事项
在使用Java Stream流时，有一些注意事项需要考虑，以确保代码的正确性和性能。以下是一些常见的注意事项：

不可重用性： 一旦创建了一个Stream对象并执行了终端操作，该Stream就不能再被重用。如果需要对同一数据集进行多次处理，应该每次都创建新的Stream对象。
惰性求值： Stream是惰性求值的，中间操作只会在终端操作触发后才会执行。这意味着中间操作不会立即产生结果，而是在需要结果时才进行计算。这可以帮助节省计算资源，但也需要谨慎处理，以免产生意外的行为。
并行流的线程安全性： 如果使用并行流（parallelStream()），要确保Stream操作是线程安全的。一些操作可能会引发并发问题，需要适当的同步或避免使用并行流。
流的关闭： 如果你使用的是基于IO的流（如Files.lines()），需要确保在使用完后关闭流，以释放资源。
性能注意事项： Stream操作的性能可能会受到数据量的影响。在大数据集上使用Stream时，要注意性能问题，可以考虑使用并行流或其他优化方法。
空值处理： 在使用Stream时，要注意空值（null）的处理，避免空指针异常。可以使用filter、map等操作来过滤或转换空值。
有状态操作： 一些Stream操作是有状态的，例如sorted和distinct，它们可能需要缓存所有元素，因此在处理大数据集时要谨慎使用，以免导致内存溢出。
自定义收集器： 如果需要自定义收集器（Collector），要确保它的线程安全性和正确性，以便在Stream中使用。
不可变性： 推荐使用不可变对象和不可变集合来处理Stream，以避免并发问题。
了解Stream操作的复杂度： 不同的Stream操作具有不同的时间复杂度。了解操作的复杂度有助于选择最适合的操作来满足性能需求。
总之，使用Java Stream流可以编写更简洁和可读性强的代码，但在使用过程中需要考虑到流的惰性求值、线程安全性、性能等方面的注意事项，以确保代码的正确性和性能。

总结
Java Stream流是一项强大的特性，可以极大地简化集合数据的处理。通过中间操作和终端操作的组合，我们可以轻松地实现各种复杂的数据处理任务。同时，流还提供了并行处理的支持，可以充分利用多核处理器的性能。

要注意的是，流是一次性的，一旦调用了终端操作，流将被消耗，不能再被复用。此外，在使用并行流时要注意线程安全的问题。

希望本文能帮助你更好地理解和使用Java Stream流，提高代码的可读性和可维护性。如果你对Java Stream流还有更多的疑问或想要深入了解，可以查阅官方文档或进一步学习相关的教程和示例。 Happy coding!
-----------------------------------
©著作权归作者所有：来自51CTO博客作者繁依Fanyi的原创作品，请联系作者获取转载授权，否则将追究法律责任
【Java 基础篇】Java Stream 流详解
https://blog.51cto.com/techfanyi/7716839