list.stream().foreach()和list.foreach()的对比-CSDN博客

转载https://baijiahao.baidu.com/s?id=1637952388544934539&wfr=spider&for=pc

1.简介

在java中有多种方式对集合进行遍历。本教程中将看两个类似的方法 Collection.stream（）.forEach（）和Collection.forEach（）。

在大多数情况下，两者都会产生相同的结果，但是，我们会看到一些微妙的差异。

2.概述

首先，创建一个迭代列表：

List<String> list = Arrays.asList("A","B","C","D");

最直接的方法是使用增强的for循环：

for(String s : list"){
	//something
}

如果我们想使用函数式Java，我们也可以使用forEach（）。我们可以直接在集合上这样做：

Consumer<String> consumer = s -> {System.out::println};
list.forEach(consumer);

或者，我们可以在集合的流上调用forEach（）：

list.stream().forEach(consumer);

两个版本都将迭代列表并打印所有元素：

ABCD ABCD

在这个简单的例子中，我们使用的forEach（）没有区别。

3.执行顺序

Collection.forEach（）使用集合的迭代器（如果指定了一个），集合里元素的处理顺序是明确的。相反，Collection.stream（）.forEach（）的处理顺序是不明确的。

在大多数情况下，我们选择上述两种方式的哪一种是没有区别的。但是有时候有。

3.1 Parallel Stream

并发流允许我们在多个线程中执行stream，在这种情况下，执行顺序也不明确的。Java只需要在调用任何最终操作（例如Collectors.toList（））之前完成所有线程。

看一个例子，首先直接在集合上调用forEach（），然后在并发流上调用：

list.forEach(System.out::Println);
System.out.println(" ");
list.parallelStream().foreach(System.out::println);

如果我们多次运行代码，我们会看到list.forEach（）以插入顺序处理元素，而 list.parallelStream（）.forEach（）在每次运行会产生不同的结果。

一个可能的输出是：

ABCD CDBA

另一个是：

ABCD DBCA

3.2 自定义迭代器

让我们使用自定义迭代器定义一个列表，以反向顺序迭代集合：

class ReverseList extends ArrayList<String>{
	@Override
	public Iterator<String> iterator(){
		int startIndex = this.size()-1;
		List<String> list = this;
		
		Iterator<String> it = new Iterator<String>(){
			private int currentIndex;
			@Override
			public boolean hasNext(){
				return currentIndex >= 0;
			}
			
			@Override
			public String next(){
				String next = list.get(currentIndex);
				currentIndex--;
				return next;
			}
			
			@Override
			public void remove(){
				throw new UnsupportedOperationException();
			}
		};
		return it;
	}
}

当我们遍历列表时，再次使用forEach（）直接在集合上，然后在流上：

List<String> myList = new ReverseList();
myList.addAll(list);
myList.forEach(System.out::Print);
System.out.println(" ");
myList.stream().forEach(System.out::print);

我们得到不同的结果：

DCBA ABCD

结果不同的原因是在列表中使用的forEach（）会使用自定义迭代器，而stream（）.forEach（）只是从列表中逐个获取元素，会忽略迭代器。

4.修改集合

很多集合在遍历的时候，不应该在结构上被修改（比如ArrayList或HashSet）。如果在迭代期间删除或添加元素，会抛出ConcurrentModification异常。

此外，集合设计为快速失败（fail-fast），这意味着一旦修改就抛出异常。

类似地，当我们在stream的执行期间添加或删除元素时，我们将得到ConcurrentModification异常。但是，异常将在稍后抛出。

两个forEach（）方法之间的另一个细微差别是Java明确允许使用迭代器修改元素。相反，stream不能。

来看一下更详细的例子。

4.1 删除元素

定义一个列表，删除最后一个元素（“D”）：

Consumer<String> removeElemet = s->{
	System.out.println(s + " " + list.size());
	if(s!=null && s.equals("A")){
		list.remove("D");
	}
}

遍历列表时，在打印第一个元素（“A”）后删除最后一个元素：

list.forEach(removeElement);

因为forEach（）是快速失败的，所以我们停止迭代并在处理下一个元素之前看到异常：

A 4
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList.forEach(ArrayList.java:1252)
at ReverseList.main(ReverseList.java:1)

让我们看看如果我们使用stream（）.forEach（）会发生什么：

list.stream().forEach(removeElement);

在这里，我们继续迭代整个列表，然后才看到异常：

A 4
B 3
C 3
null 3
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1380)
at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
at ReverseList.main(ReverseList.java:1)