详细分析Java中的list.foreach()和list.stream().foreach()_java list.stream.foreach

前言

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

先看代码示例：

使用List的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");

        // 使用List的forEach
        data.forEach(element -> {
            System.out.println("Element: " + element);
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

使用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
2
3
4
5
6
7
8
9
10
11
12
13

两者输出结果都为如下：

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

1. 基本知识

1. forEach() 是List接口的一部分，用于对列表中的每个元素执行给定的操作。与Stream API的 forEach 不同，list的 forEach 不支持并行处理，因此它在处理大量数据时可能不如Stream API高效。
   适用于简单的迭代和操作，不需要复杂的流处理。

2. stream().forEach() 是Stream API的一部分，用于对流中的每个元素执行给定的操作。使用Stream API的 forEach 允许进行更多的操作，例如过滤、映射等，因为你可以在流上链式调用其他方法。
   Stream API提供了更多的灵活性和功能，适用于处理大量数据或进行复杂的操作。

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

总结：

2. 差异之处

此处的差异之处主要讲解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);
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

截图如下：

在使用 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);
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

截图如下：

2.2 串行并行

对应上章节继续科普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");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

截图如下所示：

原本以为使用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");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

截图如下：

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

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

2.3 复杂数据处理

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

下面举例说明 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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

截图如下：

• 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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

截图如下：

• 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));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

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

截图如下：

拓展1
对于上述代码中，都有使用到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.");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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"); // 在遍历过程中增加元素
            }
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

以及删除数据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); // 在遍历过程中删除元素，可能导致异常
            }
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

最终的结果截图如下：

---

二、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"); // 在遍历过程中增加元素
            }
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

截图如下：

以及删除数据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.remove(element); // 在遍历过程中删除元素，可能导致异常
            }
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

截图如下:

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

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

截图如下：

3. 总结

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

List.forEach() 方法：

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

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

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

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

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

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

4. 彩蛋

对于上述中的代码，有一个需要注意的点：
不管是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); // 在遍历过程中删除元素，可能导致异常
            }
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

截图如下：

主要的原因在于：

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

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