6、Java核心Api系列（四）-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_22910257/article/details/145858930

五、Java流（Stream）

1、Stream的简介和用途

Java 8引入了Stream API，为Java程序员提供了一种新的处理数据集合的方式。Stream API的核心在于提供了一种声明式的、可组合的复杂数据处理流水线。Stream本质上是数据处理的管道，可以从集合、数组、文件等来源创建，并通过链式调用中间操作和终止操作来完成复杂的数据处理任务。

用途：

简化代码：Stream API通过高级的抽象和简洁的语法，大幅减少了代码的行数和复杂度。
提升效率：支持并行处理，充分利用多核处理器的计算能力，提高数据处理的效率。
灵活性：提供了丰富的中间和终止操作，允许开发者根据需求灵活构建处理流水线。

2、创建Stream的方式

Stream可以从多种数据源创建，以下是常见的几种方式：

集合：

使用Collection.stream()方法将集合转换为Stream。

例如：

List<String> list = Arrays.asList("Apple", "Banana", "Cherry");  
Stream<String> stream = list.stream();

数组：

使用Arrays.stream()方法将数组转换为Stream。

例如：

String[] array = {"Dog", "Cat", "Bird"};  
Stream<String> stream = Arrays.stream(array);

文件：

使用Files.lines()方法读取文件内容，将其转换为行流。

例如：

Path path = Paths.get("data.txt");  
try (Stream<String> stream = Files.lines(path)) {  
    // 处理流  
} catch (IOException e) {  
    e.printStackTrace();  
}

生成数值流：
- 使用IntStream.range()或LongStream.range()生成整数或长整数流。
- 例如：
```
IntStream.range(1, 10).forEach(System.out::println);  
```
自定义流：
- 使用Stream.generate()或Stream.iterate()创建无限流。
- 例如：
```
Stream<String> generatedStream = Stream.generate(() -> "Generated Element");  
```

3、Stream的中间操作

中间操作是Stream处理的核心，它们返回一个新的Stream，允许进一步操作。中间操作不会立即执行，直到遇到终止操作。

Filter：

用于过滤元素，返回满足条件的元素。

示例：

List<String> list = Arrays.asList("Apple", "Banana", "Cherry");  
list.stream()  
    .filter(fruit -> fruit.startsWith("A"))  
    .forEach(System.out::println); // 输出：Apple

Map：

用于将每个元素转换为另一个对象。

示例：

List<String> list = Arrays.asList("Apple", "Banana", "Cherry");  
list.stream()  
    .map(String::toUpperCase)  
    .forEach(System.out::println); // 输出：APPLE, BANANA, CHERRY

Sorted：

用于对元素进行排序。

示例：

List<String> list = Arrays.asList("Banana", "Apple", "Cherry");  
list.stream()  
    .sorted()  
    .forEach(System.out::println); // 输出：Apple, Banana, Cherry

Limit：

用于限制Stream的元素数量。

示例：

List<String> list = Arrays.asList("Dog", "Cat", "Bird", "Fish", "Tiger");  
list.stream()  
    .limit(3)  
    .forEach(System.out::println); // 输出：Dog, Cat, Bird

Skip：

用于跳过前N个元素。

示例：

List<String> list = Arrays.asList("Dog", "Cat", "Bird", "Fish", "Tiger");  
list.stream()  
    .skip(2)  
    .forEach(System.out::println); // 输出：Bird, Fish, Tiger

Distinct：

用于去除重复元素。

示例：

List<String> list = Arrays.asList("Dog", "Dog", "Cat", "Bird");  
list.stream()  
    .distinct()  
    .forEach(System.out::println); // 输出：Dog, Cat, Bird

Peek：

用于对每个元素进行操作，不改变元素本身。
常用于调试，打印中间结果。

示例：

List<String> list = Arrays.asList("Dog", "Cat", "Bird");  
list.stream()  
    .peek(System.out::println)  
    .forEach(s -> s.toUpperCase());

4、Stream的终止操作

终止操作用于执行Stream处理的最终操作，返回结果或引发副作用。常见的终止操作包括：

forEach：

遍历每个元素，通常用于执行副作用，如打印。

示例：

List<String> list = Arrays.asList("Apple", "Banana", "Cherry");  
list.stream().forEach(System.out::println);

Collect：

将Stream中的元素收集到集合或特定对象中。

示例：

List<String> list = Arrays.asList("Dog", "Cat", "Bird");  
Set<String> set = list.stream()  
                      .collect(Collectors.toSet());

Reduce：

将Stream中的元素累积为一个结果。

示例：

ist<Integer> list = Arrays.asList(1, 2, 3, 4);  
int sum = list.stream().reduce(0, (a, b) -> a + b); // sum = 10

FindFirst：

返回Stream中的第一个元素。

示例：

List<String> list = Arrays.asList("Banana", "Apple", "Cherry");  
Optional<String> first = list.stream().findFirst();  
first.ifPresent(System.out::println); // 输出：Banana

FindAny：

返回Stream中的任意一个元素。

示例：

List<String> list = Arrays.asList("Dog", "Cat", "Bird");  
Optional<String> any = list.stream().findAny();  
any.ifPresent(System.out::println); // 输出：Dog（顺序流）或任意元素（并行流）

Count：

返回Stream中的元素数量。

示例：

List<String> list = Arrays.asList("Dog", "Cat", "Bird");  
long count = list.stream().count(); // count = 3

Max/Min：

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

示例：

List<Integer> list = Arrays.asList(10, 5, 15, 20);  
Integer max = list.stream().max(Integer::compare); // max = 20

AllMatch/AnyMatch/NoneMatch：

检查Stream中的元素是否满足特定条件。

示例：

List<String> list = Arrays.asList("Dog", "Cat", "Bird");  
boolean allStartWithD = list.stream().allMatch(s -> s.startsWith("D")); // false  
boolean anyStartWithC = list.stream().anyMatch(s -> s.startsWith("C")); // true  
boolean noneStartWithT = list.stream().noneMatch(s -> s.startsWith("T")); // true

5、Stream的并行处理

Stream API支持并行处理，利用多核处理器的计算能力来加快数据处理速度。

顺序Stream与并行Stream：
- 顺序Stream：默认情况下，Stream是顺序处理的，所有操作按顺序执行，适合单核处理。
- 并行Stream：通过调用.parallelStream()或parallel()将Stream转换为并行Stream，适合多核处理器。

如何启用并行处理：

使用

parallelStream()

方法创建并行Stream：

List<String> list = Arrays.asList("Dog", "Cat", "Bird", "Fish", "Tiger");  
list.parallelStream().forEach(System.out::println);

并行处理的优势：
- 提高性能：通过并行执行Stream操作，减少处理时间。
- 充分利用资源：在多核处理器上，充分发挥每个核心的计算能力。
并行处理的挑战与注意事项：
- 线程安全：并行处理可能引发线程安全问题，尤其是在共享可变状态时。
- 性能开销：并行处理有一定的开销，适用于大数据量的处理，不适合小数据量的处理。
- 顺序依赖性：某些操作，如forEach，在并行环境下可能导致非确定性的结果，需要谨慎使用。
最佳实践：
- 避免共享可变状态：在并行处理中，尽量减少对共享变量的修改，使用不可变对象或本地变量。
- 谨慎使用forEach：forEach在并行环境中不保证元素的处理顺序，不适合依赖顺序的操作。
- 使用合适的数据结构：选择适合并行处理的数据结构，例如ConcurrentHashMap，以提升性能。

示例：并行处理的优势：

List<Integer> largeList = IntStream.range(0, 1000000).boxed().collect(Collectors.toList());  

// 顺序处理  
long start = System.currentTimeMillis();  
int sumSeq = largeList.stream().reduce(0, (a, b) -> {  
    return a + b;  
});  
System.out.println("顺序处理时间: " + (System.currentTimeMillis() - start) + " ms");  

// 并行处理  
start = System.currentTimeMillis();  
int sumPar = largeList.parallelStream().reduce(0, (a, b) -> a + b);  
System.out.println("并行处理时间: " + (System.currentTimeMillis() - start) + " ms");

在多核处理器上，并行处理版本的执行时间通常会显著少于顺序处理版本。

并行处理的终止操作注意事项：
- 某些终止操作如forEach在并行处理中可能导致不可预测的结果，应尽量避免使用。
- 使用collect或reduce等终止操作时，确保累加器和组合器的正确性，避免并发修改问题。

6、Stream的优化与最佳实践

选择合适的中间操作：
- 根据数据特性选择合适的中间操作，例如使用filter和map来简化数据处理流程。
- 避免在Stream链中过多的中间操作，以保持链的简洁和高效。
合理使用终止操作：
- 确保每个Stream都有一个终止操作，避免Stream链长时间处于中间状态。
- 根据需求选择合适的终止操作，例如collect适用于需要将结果保存到集合，而forEach适用于一次性遍历数据。
避免不必要的包装：
- 尽量减少不必要的对象创建和拆解，例如在map操作中尽量返回不可变对象或基础类型。
- 使用原始类型流（IntStream, LongStream, DoubleStream）来提高性能，减少自动装箱/拆箱的开销。
利用并行处理：
- 对于大规模数据处理，合理利用并行Stream来提升性能。
- 注意并行处理中的线程安全问题，确保共享变量的线程安全性。
提高代码的可读性：
- 通过合理拆分长链式调用，使得代码更加易读和维护。
- 使用方法引用和lambda表达式简化代码，但保持代码的清晰和明了。
测试和调试：
- 对于复杂的Stream处理链，进行充分的测试和调试，确保每一步的操作都是预期的。
- 使用peek方法来调试中间结果，帮助理解和排查问题。
性能分析与优化：
- 使用profilng工具分析Stream处理的性能瓶颈。
- 根据性能分析结果，优化Stream链的操作顺序和选择，提升整体处理效率。
遵循集合的不变性：
- 尽量确保在Stream处理过程中，数据元素的不可变性，避免在处理过程中修改数据导致的副作用。
- 通过使用不可变对象提升Stream处理的安全性和可维护性。

7、常见问题与解答

问：Stream和Iterator有什么不同？
- 答：Stream提供了一种更高级、更声明式的数据处理方式，而Iterator是较低层次的、命令式的遍历方式。Stream允许通过管道的方式串联多个操作，更加简洁和高效。
问：如何处理Stream中的空值？
- 答：可以通过filter(Objects::nonNull)来过滤掉空值，或者在映射操作中处理空值，避免空指针异常。
问：为什么并行Stream在某些情况下反而比顺序Stream慢？
- 答：并行Stream的创建和管理需要额外的开销，对于小规模的数据，这种开销可能超过了并行处理带来的好处。此外，如果操作本身具有高度依赖性，可能导致并行处理效果不佳。
问：如何确保并行Stream中forEach的执行顺序？
- 答：无法确保并行Stream中forEach的执行顺序。如果需要确保执行顺序，应该使用顺序Stream，或者在并行Stream中使用collect等操作收集结果后再进行有序处理。
问：Stream的终止操作可以多次执行吗？
- 答：不能。Stream一旦执行终止操作后，Stream管道就被关闭，不能再次使用。如果需要多次处理，应重新创建Stream。
问：如何处理Stream中的异常？
- 答：可以通过将处理逻辑包裹在try-catch块中，或者在lambda表达式中使用异常处理机制，例如peek方法的异常捕获。
问：Stream如何处理无限流？
- 答：Stream可以通过limit方法来限制元素的数量，或者通过takeWhile等方法来提前终止流的处理，但要注意无限流的内存占用问题，避免内存泄漏。
问：如何将Stream结果保存到文件中？
- 答：可以通过collect方法将结果收集到集合，然后利用Files.write方法将集合写入文件。或者在终止操作中直接将Stream写入文件流中。
问：Stream的中间操作是否是延迟执行的？
- 答：是的，中间操作是延迟执行的，只有当终止操作被执行时，整个Stream管道才会开始执行。这被称为“懒执行”。
问：如何监控Stream的执行情况？
- 答：可以通过调用peek方法在中间操作中添加日志记录或监控，实时查看Stream的处理情况。

8、实际案例

案例1：处理员工数据

假设有一个员工列表，需求是找出所有年龄大于30岁的员工，并将他们的工资增加10%。

List<Employee> employees = Arrays.asList(  
    new Employee("John", 35, 5000.0),  
    new Employee("Mary", 28, 4500.0),  
    new Employee("David", 40, 6000.0)  
);  

List<Employee> updatedEmployees = employees.stream()  
    .filter(e -> e.getAge() > 30)  
    .map(e -> new Employee(e.getName(), e.getAge(), e.getSalary() * 1.1))  
    .collect(Collectors.toList());  

updatedEmployees.forEach(e -> System.out.println(e));

案例2：统计文件中的单词数量

统计指定文件中单词的数量，并返回出现次数最多的前三名单词。

Path path = Paths.get("example.txt");  

Map<String, Long> wordCount = Files.lines(path)  
    .flatMap(line -> Arrays.stream(line.split(" ")))  
    .collect(Collectors.groupingBy(  
        String::toLowerCase,  
        Collectors.counting()  
    ));  

// 获取出现次数最多的前三名单词  
List<Map.Entry<String, Long>> topThree = new ArrayList<>(wordCount.entrySet()).stream()  
    .sorted((e1, e2) -> e2.getValue().compareTo(e1.getValue()))  
    .limit(3)  
    .collect(Collectors.toList());  

topThree.forEach(entry -> System.out.println(entry.getKey() + ": " + entry.getValue()));

案例3：并行计算大规模数据的总和

对于一个非常大的整数列表，计算其总和，利用并行处理提升性能。

List<Integer> largeList = IntStream.range(0, 10000000).boxed().collect(Collectors.toList());  

long start = System.currentTimeMillis();  
int sumSeq = largeList.stream().reduce(0, (a, b) -> a + b);  
System.out.println("顺序处理时间: " + (System.currentTimeMillis() - start) + " ms");  

start = System.currentTimeMillis();  
int sumPar = largeList.parallelStream().reduce(0, (a, b) -> a + b);  
System.out.println("并行处理时间: " + (System.currentTimeMillis() - start) + " ms");