目录

前言1. 基本知识2. 差异之处2.1 执行顺序2.2 串行并行2.3 复杂数据处理2.4 CRUD集合2.5 迭代器

3. 总结4. 彩蛋

前言

典故来源于项目中使用了两种方式的foreach，后面尝试体验下有何区别！

先看代码示例：

使用List的forEach：

<code>import java.util.Arrays;

import java.util.List;

public class Demo {

public static void main(String[] args) {

List<String> data = Arrays.asList("One", "Two", "Three", "Four", "Five");

// 使用List的forEach

data.forEach(element -> {

System.out.println("Element: " + element);

});

}

}

使用Stream API的forEach：

import java.util.Arrays;

import java.util.List;

public class Demo {

public static void main(String[] args) {

List<String> data = Arrays.asList("One", "Two", "Three", "Four", "Five");

// 使用Stream API的forEach

data.stream().forEach(element -> {

System.out.println("Element: " + element);

});

}

}

两者输出结果都为如下：

既然两个都输出差不多的结果，但两者还是稍微有些小区别，具体看下文！

1. 基本知识

<code>forEach() 是List接口的一部分，用于对列表中的每个元素执行给定的操作。与Stream API的 forEach 不同，list的 forEach 不支持并行处理，因此它在处理大量数据时可能不如Stream API高效。

适用于简单的迭代和操作，不需要复杂的流处理。

stream().forEach() 是Stream API的一部分，用于对流中的每个元素执行给定的操作。使用Stream API的 forEach 允许进行更多的操作，例如过滤、映射等，因为你可以在流上链式调用其他方法。

Stream API提供了更多的灵活性和功能，适用于处理大量数据或进行复杂的操作。

两者更多的区别可看下表：

总结：

2. 差异之处

此处的差异之处主要讲解<code>stream().foreach() 比 list.foreach()多的点

2.1 执行顺序

stream流中如果结合parallelStream()，会有不一样的特性！

import java.util.Arrays;

import java.util.List;

public class Demo {

public static void main(String[] args) {

List<String> data = Arrays.asList("One", "Two", "Three", "Four", "Five");

// 使用Stream API中的parallelStream forEach

data.parallelStream().forEach(element -> {

System.out.println("Element: " + element);

});

}

}

截图如下：

在使用 <code>parallelStream() 进行并行处理时，元素的处理顺序可能不会按照原始列表中的顺序输出。

并行流会将数据分成多个块，然后并行处理这些块，最后将结果合并。

因此，并行处理的结果可能在不同的块之间交错，导致输出的顺序不再按照原始列表的顺序。

想要保持顺序，可以使用 forEachOrdered() 方法，它会保证按照流的遍历顺序输出结果（并行流的情况下保持元素的遍历顺序，但可能会牺牲一些并行处理的性能优势）。示例如下：

import java.util.Arrays;

import java.util.List;

public class Demo {

public static void main(String[] args) {

List<String> data = Arrays.asList("One", "Two", "Three", "Four", "Five");

// 使用Stream API的parallelStream().forEachOrdered

data.parallelStream().forEachOrdered(element -> {

System.out.println("Element: " + element);

});

}

}

截图如下：

2.2 串行并行

对应上章节继续科普<code>parallelStream()，一般来说并行的输出速度比较快，用于对顺序输出不讲究，但是大量的数据处理可以用这个！

对于少量的数据来说，效果不明显，甚至会高于list.foreach()，所以根据情况而来，一般数据处理多，可以应用parallelStream()

import java.util.ArrayList;

import java.util.List;

public class Demo {

public static void main(String[] args) {

List<Integer> numbers = new ArrayList<>();

for (int i = 1; i <= 1000000; i++) {

numbers.add(i);

}

// 使用 Stream.forEach 进行并行处理

long startTime = System.currentTimeMillis();

numbers.parallelStream().forEach(element -> {

// 模拟一些耗时的操作

Math.pow(element, 2);

});

long endTime = System.currentTimeMillis();

System.out.println("Time taken with Stream.forEach (parallel): " + (endTime - startTime) + " ms");

}

}

截图如下所示：

原本以为使用<code>list.foreach()，时间会更长，反而时间更短：

import java.util.ArrayList;

import java.util.List;

public class Demo {

public static void main(String[] args) {

List<Integer> numbers = new ArrayList<>();

for (int i = 1; i <= 1000000; i++) {

numbers.add(i);

}

// 使用 List.forEach 进行串行处理

long startTime = System.currentTimeMillis();

numbers.forEach(element -> {

// 模拟一些耗时的操作

Math.pow(element, 2);

});

long endTime = System.currentTimeMillis();

System.out.println("Time taken with List.forEach (sequential): " + (endTime - startTime) + " ms");

}

}

截图如下：

可能是由于数据规模较小、并行处理带来的额外开销以及模拟的耗时操作较短，导致并行流的性能没有得到有效提升。

并行处理的优势在于处理大规模数据时更为显著。

2.3 复杂数据处理

Stream API提供了丰富的中间操作和终端操作，使得能够进行更复杂的数据处理。

下面举例说明 <code>filter()、map()、reduce() 这几个常用的操作方法。

filter() 用于对流中的元素进行过滤，只保留满足某个条件的元素：

import java.util.Arrays;

import java.util.List;

import java.util.stream.Collectors;

public class Demo {

public static void main(String[] args) {

List<String> data = Arrays.asList("One", "Two", "Three", "Four", "Five");

// 过滤出长度大于3的元素

List<String> filteredList = data.stream()

.filter(element -> element.length() > 3)

.collect(Collectors.toList());

System.out.println("Filtered List: " + filteredList);

}

}

截图如下：

<code>map() 用于对流中的每个元素进行映射转换，生成一个新的流：

import java.util.Arrays;

import java.util.List;

import java.util.stream.Collectors;

public class Demo {

public static void main(String[] args) {

List<String> data = Arrays.asList("One", "Two", "Three", "Four", "Five");

// 将每个元素转换为大写

List<String> uppercasedList = data.stream()

.map(String::toUpperCase)

.collect(Collectors.toList());

System.out.println("Uppercased List: " + uppercasedList);

}

}

截图如下：

<code>reduce() 用于将流中的元素逐个进行操作，最终得到一个结果

import java.util.Arrays;

import java.util.List;

import java.util.Optional;

public class Demo {

public static void main(String[] args) {

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

// 对所有元素求和

Optional<Integer> sum = numbers.stream()

.reduce((x, y) -> x + y);

sum.ifPresent(result -> System.out.println("Sum: " + result));

}

}

使用 Optional<Integer> 主要是为了处理可能没有元素的情况，避免返回 null。

考虑到 numbers 可能为空，如果直接使用 reduce((x, y) -> x + y)，当 numbers 为空时，会得到 null，而这可能导致空指针异常。

截图如下：

拓展1

对于上述代码中，都有使用到<code>Collectors.toList()

Collectors.toList() 是Collectors 工具类提供的一个静态方法，它用于将流中的元素收集到一个 List 集合中。

在Stream API中，对流进行一系列的操作后，通常会希望将结果收集到一个集合中，以便后续的操作或输出。

在实际应用中，还可以使用其他的 Collectors 方法，如 toSet()、toMap() 等，以便根据需求将元素收集到不同的集合类型中。

拓展2

对于上述reduce中，使用到了Optional 类

Optional 是Java 8引入的一个类，用于处理可能为null的值。

它的设计目的是避免使用null，减少空指针异常的发生，并提供更安全、清晰的代码。

在上述代码中，通过使用 Optional<Integer>，可以更安全地处理可能为空的情况。如果 numbers 为空，reduce 操作的结果将是 Optional.empty()，而不是 null。

import java.util.Arrays;

import java.util.List;

import java.util.Optional;

public class ReduceWithOptionalExample {

public static void main(String[] args) {

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

// 使用Optional处理可能为空的情况

Optional<Integer> sum = numbers.stream()

.reduce((x, y) -> x + y);

// 判断Optional是否包含值

if (sum.isPresent()) {

System.out.println("Sum: " + sum.get());

} else {

System.out.println("The list is empty.");

}

}

}

2.4 CRUD集合

当使用 list.foreach() 或 stream().foreach() 进行遍历操作时，如果在遍历过程中对集合进行了增、删、改的操作，可能会导致 ConcurrentModificationException 异常。

一、list.foreach()的增删：

增加数据的Demo代码：

import java.util.*;

public class Demo {

public static void main(String[] args) {

List<String> data = new ArrayList<>();

data.add("One");

data.add("Two");

data.add("Three");

// 使用 List.forEach 遍历，并在遍历过程中增加元素

data.forEach(element -> {

System.out.println("Element: " + element);

if (element.equals("Two")) {

data.add("Four"); // 在遍历过程中增加元素

}

});

}

}

以及删除数据Demo：

import java.util.*;

public class Demo {

public static void main(String[] args) {

List<String> data = new ArrayList<>();

data.add("One");

data.add("Two");

data.add("Three");

// 使用 List.forEach 遍历，并在遍历过程中删除元素

data.forEach(element -> {

System.out.println("Element: " + element);

if (element.equals("Two")) {

data.remove(element); // 在遍历过程中删除元素，可能导致异常

}

});

}

}

最终的结果截图如下：

二、<code>list.stream().foreach()的增删：

增加数据的Demo代码：

import java.util.*;

public class Demo {

public static void main(String[] args) {

List<String> data = new ArrayList<>();

data.add("One");

data.add("Two");

data.add("Three");

// 使用 Stream.forEach 遍历，并在遍历过程中增加元素

data.stream().forEach(element -> {

System.out.println("Element: " + element);

if (element.equals("Two")) {

data.add("Four"); // 在遍历过程中增加元素

}

});

}

}

截图如下：

以及删除数据Demo：

<code>import java.util.*;

public class Demo {

public static void main(String[] args) {

List<String> data = new ArrayList<>();

data.add("One");

data.add("Two");

data.add("Three");

// 使用 Stream.forEach 遍历，并在遍历过程中删除元素

data.stream().forEach(element -> {

System.out.println("Element: " + element);

if (element.equals("Two")) {

data.remove(element); // 在遍历过程中删除元素，可能导致异常

}

});

}

}

截图如下:

通过上述四个程序的执行结果，可以得到什么体会呢？？？

<code>stream().foreach()在操作集合的CRUD的时候，执行错误之后，还是会迭代整个列表，才看到异常

这也证明stream().foreach()为并行执行处理数据，而不是串行

那有办法解决这种异常的情况么，又能对集合进行CRUD！（答案是有的，可看如下正文）

2.5 迭代器

通过上述的阅读，急需需要一个对集合的CRUD做一个安全性的迭代！

于是有了如下的解决方式：

import java.util.*;

public class Demo {

public static void main(String[] args) {

List<String> data = new ArrayList<>();

data.add("One");

data.add("Two");

data.add("Three");

// 使用迭代器遍历，并在条件满足时删除元素

Iterator<String> iterator = data.iterator();

while (iterator.hasNext()) {

String element = iterator.next();

System.out.println("Element: " + element);

if (element.equals("Two")) {

iterator.remove(); // 尝试在不支持结构性修改的列表上进行删除操作，抛出异常

}

}

System.out.println("Modified List: " + data);

}

}

截图如下：

3. 总结

总结起来，对于上面的代码学习，主要涉及了两种遍历集合的方式：List.forEach() 和 List.stream().forEach()。下面对这两种方式的区别进行总结：

List.forEach() 方法：

遍历是在当前线程中按顺序执行的，对集合元素的操作是同步的。

适用于简单的、顺序执行的遍历操作。

不支持并行操作，不保证源数据的顺序。

List.stream().forEach() 方法：

可以利用并行流进行多线程处理，提高遍历效率，不保证源数据的顺序。

适用于更复杂的、并行处理的遍历操作，可以配合 Stream 的其他操作进行更灵活的数据处理。

4. 彩蛋

对于上述中的代码，有一个需要注意的点：

不管是<code>list.foreach()还是list.stream().foreach()，集合的CRUD都会出现会爆：Exception in thread "main" java.lang.UnsupportedOperationException的错误，举一个例子。

import java.util.*;

public class Demo {

public static void main(String[] args) {

List<String> data = Arrays.asList("One", "Two", "Three");

// 使用 List.forEach 遍历，并在遍历过程中删除元素

data.forEach(element -> {

System.out.println("Element: " + element);

if (element.equals("Two")) {

data.remove(element); // 在遍历过程中删除元素，可能导致异常

}

});

}

}

截图如下：

主要的原因在于：

<code>Arrays.asList("One", "Two", "Three", "Four", "Five") 创建的列表是由数组支持的固定大小的列表。

这意味着该列表不支持结构性修改操作（如添加、删除），并且会在尝试进行这些操作时抛出UnsupportedOperationException 异常。