本文详细介绍了Java Stream流的主要特点和用法，包括链式操作、懒加载、过滤和映射、聚合操作、排序、并行流等。通过实例展示了如何使用Stream进行数据处理，如过滤偶数、映射转换、聚合计算等，并讨论了并行流的性能优势和注意事项。此外，文章还涵盖了短路操作、非终止操作、分组和分区、自定义操作以及流的序列化。最后，探讨了流的无序性、延迟加载机制、迭代器与流的对比，以及多层嵌套流的使用，强调了Stream在数据处理中的高效性和灵活性。
Stream（流）是Java 8引入的新特性，它是一种处理集合数据的高级抽象概念。Stream流提供了一种更为简洁、强大和易于使用的方式来操作数据集合，可以进行过滤、映射、排序、聚合等各种操作，同时还支持并行处理，提高了代码的可读性和性能。
目录
一、一些特点与用法
1. 链式操作：
链式操作是指在Stream流中可以连续地进行多个操作，而不需要中间的临时变量或额外的处理步骤。它能够简化代码，使数据的处理流程更加清晰和易于理解。
以下是一个示例代码，展示了如何使用链式操作对一个整数列表进行一系列的操作：
import java.util.ArrayList;
import java.util.List;
public class ChainedOperationsExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
int sum = numbers.stream()
.filter(n -> n % 2 == 0) // 筛选出偶数
.map(n -> n * 2) // 将偶数乘以2
.reduce(0, Integer::sum); // 对结果求和
System.out.println("Sum: " + sum);
}
}在上述代码中，我们首先创建了一个整数列表 `numbers`，其中包含了一些整数。然后我们通过 `stream()` 方法将列表转换为一个流，这样我们就可以在流上进行一系列的操作。
在链式操作中，我们首先使用 `filter` 操作筛选出列表中的偶数。通过使用 lambda 表达式 `n -> n % 2 == 0`，我们可以判断一个数是否为偶数。在符合条件的元素中，我们继续进行 `map` 操作，将每个偶数乘以2，使用 lambda 表达式 `n -> n * 2` 来实现乘法操作。
最后，我们使用 `reduce` 操作对结果求和，初始值设为0，并使用 `Integer::sum` 来将两个整数相加。最终，我们得到了筛选出的偶数乘以2之后的结果的和。
通过链式操作，我们可以在不引入额外变量或处理步骤的情况下，直接在流上进行一系列的操作，使代码更加简洁和易读。
输出结果为：
Sum: 20这个例子只是链式操作的一个简单示例，实际上你可以根据需要在链式操作中进行更多的中间操作和终止操作，以满足具体的业务需求。
2. 懒加载：
懒加载（Lazy Evaluation）是指在需要的时候才进行计算或处理，而不是立即执行。在Java的Stream流中，懒加载是一种重要的特性，它使得流的中间操作可以延迟执行，只有在终止操作被调用时才会触发中间操作的执行。
以下是一个示例代码，展示使用懒加载的Stream流操作：
import java.util.Arrays;
import java.util.List;
public class LazyEvaluationExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave", "Eve");
names.stream()
.filter(name -> {
System.out.println("Filtering: " + name);
return name.length() > 3;
})
.map(name -> {
System.out.println("Mapping: " + name);
return name.toUpperCase();
})
.forEach(System.out::println);
}
}在上述代码中，我们创建了一个字符串列表 `names`，其中包含了一些名字。然后我们通过 `stream()` 方法将列表转换为一个流，并在流上进行一系列的操作。
在链式操作中，我们首先使用 `filter` 操作筛选出名字长度大于3的元素，通过使用 lambda 表达式 `name -> name.length() > 3` 来判断名字长度是否大于3。在执行 `filter` 操作的过程中，我们添加了一行 `System.out.println` 语句，用于打印筛选的过程。
然后，我们使用 `map` 操作将每个名字转换为大写字母，并通过 lambda 表达式 `name -> name.toUpperCase()` 实现转换操作。同样，我们在 `map` 操作中添加了一行 `System.out.println` 语句，用于打印映射的过程。
最后，我们使用 `forEach` 操作对结果进行遍历，并使用方法引用 `System.out::println` 打印每个结果。
当我们运行这段代码时，输出结果如下所示：
Filtering: Alice
Mapping: Alice
ALICE
Filtering: Bob
Mapping: Bob
BOB
Filtering: Charlie
Mapping: Charlie
CHARLIE
Filtering: Dave
Mapping: Dave
Filtering: Eve
Mapping: Eve
EVE从输出结果中我们可以发现，中间操作的执行是懒加载的。即只有在终止操作 `forEach` 被调用时，中间操作才会被触发执行。这意味着在我们的例子中，只有在执行 `forEach` 时，才会执行 `filter` 和 `map` 操作。这种延迟计算的特性可以提高性能并节省资源，特别是在操作大量数据时。
懒加载是Stream流的一个重要特性，允许我们只在需要的时候才对数据进行处理，提高了整体的计算效率。通过合理地运用懒加载的特性，我们可以避免不必要的计算开销，提升代码的性能和可维护性。
3. 过滤和映射：
过滤（Filter）和映射（Map）是Stream流中常用的中间操作之一，用于筛选和转换流中的元素。
1）. 过滤（Filter）操作：
过滤操作用于根据指定的条件筛选出流中满足条件的元素，构成一个新的流。它接受一个Predicate函数式接口作为参数，该接口定义了一个判断条件的方法。只有满足条件的元素才会通过过滤操作后保留在新的流中。
以下是一个示例代码，展示使用过滤操作筛选出列表中的偶数：
import java.util.Arrays;
import java.util.List;
public class FilterExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.toList();
System.out.println("Even numbers: " + evenNumbers);
}
}在上述代码中，我们首先创建了一个整数列表 `numbers`，其中包含了一些整数。然后通过 `stream()` 方法将列表转换为一个流。
在链式操作中，我们使用 `filter` 操作筛选出列表中的偶数。通过使用 lambda 表达式 `n -> n % 2 == 0`，我们判断一个数是否为偶数。只有满足条件的偶数才会通过过滤操作，并被保留在新的流中。
最后，我们使用 `toList` 终止操作将过滤后的元素收集到一个新的列表中。我们可以通过调用 `evenNumbers.stream().forEach(System.out::println);` 打印筛选出的偶数。
输出结果为：
Even numbers: [2, 4, 6]2). 映射（Map）操作：
映射操作用于对流中的每个元素执行指定的转换操作，将输入流中的元素转换为输出流中的元素。它接受一个Function函数式接口作为参数，该接口定义了一个方法来执行元素的转换操作。
以下是一个示例代码，展示使用映射操作将字符串列表中的每个元素转换为大写字母：
import java.util.Arrays;
import java.util.List;
public class MapExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> upperCaseNames = names.stream()
.map(String::toUpperCase)
.toList();
System.out.println("Upper case names: " + upperCaseNames);
}
}在上述代码中，我们创建了一个字符串列表 `names`，其中包含了一些名字。然后通过 `stream()` 方法将列表转换为一个流。
在链式操作中，我们使用 `map` 操作将每个名字转换为大写字母。通过方法引用 `String::toUpperCase`，我们可以很方便地对每个名字执行转换操作。
最后，我们使用 `toList` 终止操作将转换后的元素收集到一个新的列表中。
输出结果为：
Upper case names: [ALICE, BOB, CHARLIE]过滤和映射是Stream流中非常常用的操作，能够对流中的元素进行筛选和转换，从而得到符合需求的新流。通过合理地运用这两种操作，我们可以对数据进行精确的筛选和转换，提高代码的灵活性和可读性。
4. 聚合操作：
Stream流提供了一系列的聚合操作，如count、min、max、average等，用于对流中的元素进行统计和计算。
以下是一些常见的聚合操作：
1）. count操作：
`count` 操作用于计算流中的元素个数，返回流中的元素数量。
import java.util.stream.Stream;
public class CountExample {
public static void main(String[] args) {
long count = Stream.of("apple", "banana", "orange", "grape")
.count();
System.out.println("Total count: " + count);
}
}输出结果为：
Total count: 42）. min和max操作：
`min` 和 `max` 操作分别用于找到流中的最小值和最大值。它们要求流的元素类型实现了 `Comparable` 接口，或传递一个自定义的比较器。
示例代码：
import java.util.stream.Stream;
public class MinMaxExample {
public static void main(String[] args) {
int minValue = Stream.of(10, 5, 8, 3, 6)
.min(Integer::compareTo)
.orElse(0);
int maxValue = Stream.of(10, 5, 8, 3, 6)
.max(Integer::compareTo)
.orElse(0);
System.out.println("Min value: " + minValue);
System.out.println("Max value: " + maxValue);
}
}输出结果为：
Min value: 3
Max value: 103）. sum、average和reduce操作：
`sum` 操作用于计算流中元素的总和，适用于数值类型的流。`average` 操作用于计算流中元素的平均值，同样适用于数值类型的流。`reduce` 操作用于根据指定的操作对流中的元素进行归约。
示例代码：
import java.util.stream.Stream;
public class AggregateExample {
public static void main(String[] args) {
int sum = Stream.of(1, 2, 3, 4, 5)
.sum();
double average = Stream.of(1, 2, 3, 4, 5)
.average()
.orElse(0.0);
int product = Stream.of(1, 2, 3, 4, 5)
.reduce(1, (a, b) -> a * b);
System.out.println("Sum: " + sum);
System.out.println("Average: " + average);
System.out.println("Product: " + product);
}
}输出结果为：
Sum: 15
Average: 3.0
Product: 120聚合操作允许我们对流中的元素进行统计、汇总和归约，从而得到最终的结果。通过合理地使用聚合操作，我们可以在流中轻松地进行元素的统计和计算，简化代码并提高代码的可读性和可维护性。
5. 排序：
排序是Stream流中一种常见的中间操作，用于对流中的元素进行排序。排序操作能够按照指定的比较规则重新排列流中的元素。以下是一个示例代码，展示使用排序操作对字符串列表进行排序：
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class SortingExample {
public static void main(String[] args) {
List<String> fruits = Arrays.asList("apple", "orange", "banana", "grape");
List<String> sortedFruits = fruits.stream()
.sorted()
.collect(Collectors.toList());
System.out.println("Sorted fruits: " + sortedFruits);
}
}在上述代码中，我们首先创建了一个字符串列表 `fruits`，其中包含了一些水果名称。然后通过 `stream()` 方法将列表转换为一个流。
在链式操作中，我们使用 `sorted` 操作对流中的元素进行排序。默认情况下，排序操作会按照元素的自然顺序进行排序（对于字符串，按照字母顺序）。在这个例子中，我们使用的是默认的自然排序。
最后，我们通过 `collect` 方法将排序后的元素收集到一个新的列表中，使用 `Collectors.toList()` 来生成列表。
输出结果为：
Sorted fruits: [apple, banana, grape, orange]除了默认的自然排序外，我们还可以传递一个自定义的比较器给 `sorted` 操作，以便按照我们的需求进行排序。比如，对于一个数字列表，我们可以使用自定义比较器来实现按照数字大小进行排序：
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
public class SortingExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(5, 3, 8, 2, 1);
List<Integer> sortedNumbers = numbers.stream()
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
System.out.println("Sorted numbers: " + sortedNumbers);
}
}在上述代码中，我们创建了一个整数列表 `numbers`，其中包含了一些数字。然后通过 `stream()` 方法将列表转换为一个流。
在链式操作中，我们使用 `sorted` 操作对流中的元素进行排序，并传递了一个反向的比较器 `Comparator.reverseOrder()` 来实现逆序排序。
最后，我们通过 `collect` 方法将排序后的元素收集到一个新的列表中，并使用 `Collectors.toList()` 生成列表。
输出结果为：
Sorted numbers: [8, 5, 3, 2, 1]排序操作允许我们按照不同的规则对流中的元素进行排序，从而得到排序后的结果。通过合理地使用排序操作，我们可以灵活地对元素进行排序，提高代码的可读性和可维护性。
6. 并行流：
并行流（Parallel Streams）是Java 8引入的一个特性，它允许我们方便地在多个线程上并行地处理流中的元素。通过并行流，我们可以利用多核处理器的优势，加速流操作的执行。
在使用并行流时，我们可以使用 `parallel` 方法将顺序流转换为并行流，也可以使用 `sequential` 方法将并行流转换为顺序流。以下是一个示例代码，展示使用并行流对一个整数流中的元素进行求和：
import java.util.stream.IntStream;
public class ParallelStreamExample {
public static void main(String[] args) {
int sum = IntStream.rangeClosed(1, 100000)
.parallel()
.sum();
System.out.println("Sum: " + sum);
}
}在上述代码中，我们使用 `IntStream.rangeClosed` 创建了一个整数流，范围从1到100000。然后通过 `parallel` 方法将顺序流转换为并行流。
在最后的 `sum` 操作中，流中的元素被分配给多个线程并行地进行求和计算。最终的求和结果将会是所有
最低0.47元/天 解锁文章
扫一扫
1471
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
