Java Stream 全面解析

Java Stream 全面解析

Java 8 引入的 Stream API 提供了一种高效且声明式的方式来处理集合数据。Stream 允许你以函数式编程风格操作数据，支持并行处理，并且可以显著简化代码。下面我们将从 创建操作、中间操作 和 终端操作 三个方面进行全面深入的解析，并给出代码示例。

1. 创建操作

创建 Stream 的方式有多种，以下是常见的创建方式：

1.1 从集合创建

List<String> list = Arrays.asList("apple", "banana", "cherry");
Stream<String> streamFromList = list.stream();

1.2 从数组创建

String[] array = {"apple", "banana", "cherry"};
Stream<String> streamFromArray = Arrays.stream(array);

1.3 使用 Stream.of

Stream<String> streamOf = Stream.of("apple", "banana", "cherry");

1.4 使用 Stream.iterate

Stream<Integer> streamIterate = Stream.iterate(0, n -> n + 2).limit(5); // 0, 2, 4, 6, 8

1.5 使用 Stream.generate

Stream<Double> streamGenerate = Stream.generate(Math::random).limit(5); // 5个随机数

1.6 使用 Files.lines 从文件创建

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

Stream<String> lines = Files.lines(Paths.get("file.txt")); // 从文件中读取行

2. 中间操作

中间操作返回一个新的 Stream，可以链式调用。常见的中间操作包括：

2.1 filter

过滤流中的元素。

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
List<String> filteredList = list.stream()
                                .filter(s -> s.length() > 5)
                                .collect(Collectors.toList());
System.out.println(filteredList); // [banana, cherry]

2.2 map

将流中的每个元素映射为另一个元素。

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<Integer> lengths = list.stream()
                            .map(String::length)
                            .collect(Collectors.toList());
System.out.println(lengths); // [5, 6, 6]

2.3 flatMap

将流中的每个元素映射为一个流，然后将所有流合并为一个流。

List<List<String>> nestedList = Arrays.asList(
    Arrays.asList("apple", "banana"),
    Arrays.asList("cherry", "date")
);
List<String> flatList = nestedList.stream()
                                  .flatMap(List::stream)
                                  .collect(Collectors.toList());
System.out.println(flatList); // [apple, banana, cherry, date]

2.4 sorted

对流中的元素进行排序。

List<String> list = Arrays.asList("banana", "apple", "cherry");
List<String> sortedList = list.stream()
                              .sorted()
                              .collect(Collectors.toList());
System.out.println(sortedList); // [apple, banana, cherry]

2.5 distinct

去除流中的重复元素。

List<String> list = Arrays.asList("apple", "banana", "apple", "cherry");
List<String> distinctList = list.stream()
                                .distinct()
                                .collect(Collectors.toList());
System.out.println(distinctList); // [apple, banana, cherry]

2.6 limit

截取流中的前 N 个元素。

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
List<String> limitedList = list.stream()
                               .limit(2)
                               .collect(Collectors.toList());
System.out.println(limitedList); // [apple, banana]

2.7 skip

跳过流中的前 N 个元素。

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
List<String> skippedList = list.stream()
                               .skip(2)
                               .collect(Collectors.toList());
System.out.println(skippedList); // [cherry, date]

3. 终端操作

终端操作触发流的执行并产生结果或副作用。常见的终端操作包括：

3.1 forEach

遍历流中的每个元素。

List<String> list = Arrays.asList("apple", "banana", "cherry");
list.stream().forEach(System.out::println); // apple, banana, cherry

3.2 collect

将流中的元素收集到集合或其他数据结构中。

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> collectedList = list.stream().collect(Collectors.toList());
System.out.println(collectedList); // [apple, banana, cherry]

3.3 reduce

将流中的元素通过某种操作组合起来。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = numbers.stream().reduce(Integer::sum);
sum.ifPresent(System.out::println); // 15

3.4 count

计算流中元素的数量。

List<String> list = Arrays.asList("apple", "banana", "cherry");
long count = list.stream().count();
System.out.println(count); // 3

3.5 anyMatch

检查流中是否有任意一个元素满足条件。

List<String> list = Arrays.asList("apple", "banana", "cherry");
boolean anyMatch = list.stream().anyMatch(s -> s.startsWith("b"));
System.out.println(anyMatch); // true

3.6 allMatch

检查流中是否所有元素都满足条件。

List<String> list = Arrays.asList("apple", "banana", "cherry");
boolean allMatch = list.stream().allMatch(s -> s.length() > 3);
System.out.println(allMatch); // true

3.7 noneMatch

检查流中是否没有元素满足条件。

List<String> list = Arrays.asList("apple", "banana", "cherry");
boolean noneMatch = list.stream().noneMatch(s -> s.startsWith("z"));
System.out.println(noneMatch); // true

3.8 findFirst

返回流中的第一个元素。

List<String> list = Arrays.asList("apple", "banana", "cherry");
Optional<String> firstElement = list.stream().findFirst();
firstElement.ifPresent(System.out::println); // apple

3.9 findAny

返回流中的任意一个元素（通常在并行流中使用）。

List<String> list = Arrays.asList("apple", "banana", "cherry");
Optional<String> anyElement = list.stream().findAny();
anyElement.ifPresent(System.out::println); // 可能是 apple, banana, cherry

3.10 min 和 max

返回流中的最小或最大元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> min = numbers.stream().min(Integer::compareTo);
Optional<Integer> max = numbers.stream().max(Integer::compareTo);
min.ifPresent(System.out::println); // 1
max.ifPresent(System.out::println); // 5

3.11 toArray

将流中的元素转换为数组。

List<String> list = Arrays.asList("apple", "banana", "cherry");
String[] array = list.stream().toArray(String[]::new);
System.out.println(Arrays.toString(array)); // [apple, banana, cherry]

4. 并行流

通过 parallelStream() 可以轻松实现并行处理，提高性能。

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");
list.parallelStream().forEach(System.out::println); // 并行处理

总结

Java Stream 提供了丰富的操作，包括 创建操作、中间操作 和 终端操作。通过熟练掌握这些操作，你可以编写出简洁、高效且易于维护的代码。以下是关键点：

• 创建操作：如 stream(), Stream.of, Stream.iterate, Stream.generate 等。
• 中间操作：如 filter, map, flatMap, sorted, distinct, limit, skip 等。
• 终端操作：如 forEach, collect, reduce, count, anyMatch, allMatch, noneMatch, findFirst, findAny, min, max, toArray 等。

希望这些内容能帮助你全面掌握 Java Stream！