parallelStream 详细解析 Java 8 Stream API 中的 parallelStream 方法

IT农民工~

于 2024-07-16 14:52:34 发布

阅读量642

点赞数 11

文章标签： java python 前端

本文链接：https://blog.csdn.net/anyifeiyi/article/details/139988453

版权

Java Stream 并行流（parallelStream）详解

在Java 8中引入了Stream API，它为处理集合数据提供了强大而简洁的方式。Stream API允许我们以声明式的方式对数据进行操作，使得代码更易读、更具表现力。
其中，并行流（parallelStream）是Stream API的一个重要特性，它能够显著提升处理大数据量集合时的性能。

1. 什么是并行流？

并行流是Java中Stream API的一种特殊流，它允许流中的元素在多个线程上并行处理。在处理大型数据集合时，并行流可以自动将数据分成多个部分，并在多个线程上同时处理这些部分，从而加快处理速度。相比之下，普通的串行流（sequential stream）则是在单个线程上顺序处理数据。

2. 使用并行流的场景

使用并行流可以显著提升在多核处理器上的处理速度，特别是在以下情况下特别有用：

数据量大：当处理的数据量非常大时，并行流可以利用多核处理器的优势，加速数据处理过程。
计算密集型操作：如大量的数据计算、过滤、映射等操作，这些操作可以并行化执行以提高效率。
IO密集型操作：虽然IO操作本身不能并行化，但是在处理IO操作返回的数据时，可以利用并行流进行并发处理。

3. 并行流的创建与使用

在Java中，我们可以通过将普通流转换为并行流来使用并行处理：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 创建并行流
Stream<Integer> parallelStream = numbers.parallelStream();

// 使用并行流进行操作
parallelStream.map(i -> i * 2)
             .forEach(System.out::println);

在上面的例子中，parallelStream() 方法将普通的 numbers 集合转换为并行流，并且通过 map 方法对每个元素进行乘以2的操作，然后通过 forEach 方法输出结果。在实际运行时，这些操作可以在多个线程上并发执行，加快处理速度。

假设我们有一个字符串列表，我们想要统计列表中所有字符串的长度之和：

java
List<String> words = Arrays.asList("Java", "Stream", "API", "Parallel", "Processing");

// 普通流处理
int totalLength = words.stream()
                       .mapToInt(String::length)
                       .sum();
System.out.println("普通流处理结果：" + totalLength);

// 并行流处理
int parallelTotalLength = words.parallelStream()
                               .mapToInt(String::length)
                               .sum();
System.out.println("并行流处理结果：" + parallelTotalLength);

在这个示例中，使用并行流可以在多线程上并发计算字符串的长度，从而加快求和操作的速度。
当使用Java的并行流（parallelStream）时，通常涉及对集合数据进行并行处理，下面是几个直观易懂的例子来介绍其使用：

示例一：并行计算元素平方和

假设我们有一个整数列表，我们想要计算每个元素的平方，并将这些平方值相加。这是一个典型的并行流应用场景。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 使用串行流计算平方和
int sumOfSquaresSequential = numbers.stream()
                                    .map(x -> x * x)
                                    .reduce(0, Integer::sum);
System.out.println("串行流计算平方和：" + sumOfSquaresSequential);

// 使用并行流计算平方和
int sumOfSquaresParallel = numbers.parallelStream()
                                  .map(x -> x * x)
                                  .reduce(0, Integer::sum);
System.out.println("并行流计算平方和：" + sumOfSquaresParallel);

解释：

numbers.parallelStream() 将列表转换为并行流，允许平方计算在多个线程上并行执行。
.map(x -> x * x) 对流中的每个元素进行平方操作。
.reduce(0, Integer::sum) 对所有平方值进行求和操作。
并行流在这种情况下可以利用多核处理器的能力，加速对大量数据的处理。

示例二：并行过滤与收集

假设我们有一个字符串列表，我们希望并行地过滤出长度大于3的字符串，并将它们收集到一个新的列表中。

List<String> words = Arrays.asList("Java", "Stream", "API", "Parallel", "Processing");

// 使用串行流过滤和收集
List<String> longWordsSequential = words.stream()
                                        .filter(word -> word.length() > 3)
                                        .collect(Collectors.toList());
System.out.println("串行流过滤结果：" + longWordsSequential);

// 使用并行流过滤和收集
List<String> longWordsParallel = words.parallelStream()
                                      .filter(word -> word.length() > 3)
                                      .collect(Collectors.toList());
System.out.println("并行流过滤结果：" + longWordsParallel);

解释：

words.parallelStream() 将字符串列表转换为并行流，允许过滤操作在多个线程上并行执行。
.filter(word -> word.length() > 3) 并行过滤出长度大于3的字符串。
.collect(Collectors.toList()) 将过滤后的元素收集到新的列表中。
并行流在处理大量数据时，可以显著提高过滤和收集操作的效率。

示例三：并行排序

假设我们有一个包含许多元素的列表，我们希望并行地对其进行排序。

List<Integer> numbers = Arrays.asList(10, 5, 7, 1, 8, 3, 9, 2, 4, 6);

// 使用串行流排序
List<Integer> sortedNumbersSequential = numbers.stream()
                                              .sorted()
                                              .collect(Collectors.toList());
System.out.println("串行流排序结果：" + sortedNumbersSequential);

// 使用并行流排序
List<Integer> sortedNumbersParallel = numbers.parallelStream()
                                            .sorted()
                                            .collect(Collectors.toList());
System.out.println("并行流排序结果：" + sortedNumbersParallel);

解释：

numbers.parallelStream() 将整数列表转换为并行流，允许排序操作在多个线程上并行执行。
.sorted() 对流中的元素进行排序。
.collect(Collectors.toList()) 将排序后的元素收集到新的列表中。
并行流在这里可以加速排序过程，特别是当处理大型列表时，性能提升尤为显著。

这些例子展示了并行流如何在不同情况下应用，通过利用多线程处理能力，提升了处理大数据量集合时的效率和性能。