java8 foreach 伟参_【java8】慎用java8的foreach循环

+警告

这篇文章作废掉，是由一个错误的测试方法得到的一个错误结论，后续修正结果正在测试，将贴上。

虽然java8出来很久了，但是之前用的一直也不多，最近正好学习了java8，推荐一本书还是不错的。因为学习了Java8，所以只要能用到的地方都会去用，尤其是Java8的Stream，感觉用起来觉得很方便，因为点点点就出来了，而且代码那么简洁。现在开始慢慢深入了解java8，发现很多东西不能看表面。

比如常规遍历一个集合，下面给出例子：

1.首先遍历一个List

方式1.一开始是这样的：

public static void test1(List list) {

for (int i = 0; i < list.size(); i++) {

System.out.println(list.get(i));

}

}

方式2.当然稍微高级一点的是这样：

public static void test2(List list) {

for (int i = 0,lengh=list.size(); i < lengh; i++) {

System.out.println(list.get(i));

}

}

方式3.还有就是Iterator遍历：

public static void test3(List list) {

Iterator iterator = list.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

}

方式4.后来有了增强for循环：

public static void test4(List list) {

for(String str:list){

System.out.println(str);

}

}

方式5.java8以后新增的方式：

public static void test5(List list) {

//list.forEach(System.out::println);和下面的写法等价

list.forEach(str->{

System.out.println(str);

});

}

方式6.还有另一种：

public static void test6(List list) {

list.iterator().forEachRemaining(str->{

System.out.println(str);

});

}

应该没有其他的了吧，上面六中方法，按我的使用习惯5最常用，4偶尔使用，其他的基本就不怎么用了，使用5的原因是因为方便书写，提示就可以写出来，偶尔使用4的原因是，5不方便计数用，下面进行性能测试，String不具备代表性，决定使用对象，简单的一个测试类如下：

一个简单的测试，内容不要太在意，简单计算hashCode：

package test;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class Test8 {

public static void main(String[] args) {

List list=new ArrayList<>();

for(int i=0;i<10;i++){

list.add(new Dog(i,"dog"+i));

}

long nanoTime = System.nanoTime();

test1(list);

long nanoTime1 = System.nanoTime();

test2(list);

long nanoTime2 = System.nanoTime();

test3(list);

long nanoTime3 = System.nanoTime();

test4(list);

long nanoTime4 = System.nanoTime();

test5(list);

long nanoTime5 = System.nanoTime();

test6(list);

long nanoTime6 = System.nanoTime();

System.out.println((nanoTime1-nanoTime)/1000000.0);

System.out.println((nanoTime2-nanoTime1)/1000000.0);

System.out.println((nanoTime3-nanoTime2)/1000000.0);

System.out.println((nanoTime4-nanoTime3)/1000000.0);

System.out.println((nanoTime5-nanoTime4)/1000000.0);

System.out.println((nanoTime6-nanoTime5)/1000000.0);

}

public static void test1(List list) {

for (int i = 0; i < list.size(); i++) {

list.get(i).hashCode();

}

}

public static void test2(List list) {

for (int i = 0,lengh=list.size(); i < lengh; i++) {

list.get(i).hashCode();

}

}

public static void test3(List list) {

Iterator iterator = list.iterator();

while(iterator.hasNext()){

iterator.next().hashCode();

}

}

public static void test4(List list) {

for(Dog dog:list){

dog.hashCode();

}

}

public static void test5(List list) {

//list.forEach(System.out::println);和下面的写法等价

list.forEach(dog->{

dog.hashCode();

});

}

public static void test6(List list) {

list.iterator().forEachRemaining(dog->{

dog.hashCode();

});

}

}

class Dog{

private int age;

private String name;

public Dog(int age, String name) {

super();

this.age = age;

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

return "Dog [age=" + age + ", name=" + name + "]";

}

}

运行三次取平均值，机器配置就不说了，因为我不是比较的绝对值，我是比较的这几种方式的相对值，数据结果，趋势图如下：

然后去掉表现一直很稳定的方式5和百万级数据量以上的数据，来分析结果：

可以得出一个非常吓人的结果，java8的foreach每次循环的耗时竟然高达100毫秒以上，虽然它比较稳定(算是优点吧)。所以得出以下结论：

在正常使用(数据量少于百万以下)，正常(非并行)遍历一个集合的时候：

不要使用java8的foreach，每次耗时高达100毫秒以上

提前计算出大小的普通for循环，耗时最小，但是书写麻烦

增强for循环表现良好

测试LinkedList

只为了验证最后的观点，所以只测试增强for循环和java8foreach循环：

经过一轮测试，java8foreach一如既往的稳定高耗时，增强for循环依然很给力。

2.再次遍历一个Set

使用以相同的方式测试HashSet，测试方法如下：

package test;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

public class Test9 {

public static void main(String[] args) {

Set set = new HashSet<>();

for (int i = 0; i < 10_000_000; i++) {

set.add(new Dog(i, "dog" + i));

}

long nanoTime = System.nanoTime();

test1(set);

long nanoTime1 = System.nanoTime();

test2(set);

long nanoTime2 = System.nanoTime();

test3(set);

long nanoTime3 = System.nanoTime();

test4(set);

long nanoTime4 = System.nanoTime();

System.out.println((nanoTime1 - nanoTime) / 1000000.0);

System.out.println((nanoTime2 - nanoTime1) / 1000000.0);

System.out.println((nanoTime3 - nanoTime2) / 1000000.0);

System.out.println((nanoTime4 - nanoTime3) / 1000000.0);

}

public static void test1(Set list) {

Iterator iterator = list.iterator();

while (iterator.hasNext()) {

iterator.next().hashCode();

}

}

public static void test2(Set list) {

for (Dog dog : list) {

dog.hashCode();

}

}

public static void test3(Set list) {

list.forEach(dog -> {

dog.hashCode();

});

}

public static void test4(Set list) {

list.iterator().forEachRemaining(dog -> {

dog.hashCode();

});

}

}

经过计算得出如下结果：

不难发现，java8的foreach依然每次耗时100ms以上，最快的变成了增强for循环，Iterator遍历和java8的iterator().forEachRemaining差不多。

3.最后遍历Map

依然使用相同的方式测试Map集合遍历，测试类如下：

package test;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

public class Test10 {

public static void main(String[] args) {

Map map = new HashMap<>();

for (int i = 0; i < 1000_000; i++) {

map.put("dog" + i, new Dog(i, "dog" + i));

}

long nanoTime = System.nanoTime();

test1(map);

long nanoTime1 = System.nanoTime();

test2(map);

long nanoTime2 = System.nanoTime();

test3(map);

long nanoTime3 = System.nanoTime();

test4(map);

long nanoTime4 = System.nanoTime();

System.out.println((nanoTime1 - nanoTime) / 1000000.0);

System.out.println((nanoTime2 - nanoTime1) / 1000000.0);

System.out.println((nanoTime3 - nanoTime2) / 1000000.0);

System.out.println((nanoTime4 - nanoTime3) / 1000000.0);

}

public static void test1(Map map) {

Iterator> entries = map.entrySet().iterator();

while (entries.hasNext()) {

Map.Entry entry = entries.next();

int code=entry.getKey().hashCode()+entry.getValue().hashCode();

}

}

public static void test2(Map map) {

for (Map.Entry entry : map.entrySet()) {

int code=entry.getKey().hashCode()+entry.getValue().hashCode();

}

}

public static void test3(Map map) {

for (String key : map.keySet()) {

int code=key.hashCode()+map.get(key).hashCode();

}

}

public static void test4(Map map) {

map.forEach((key, value) -> {

int code=key.hashCode()+value.hashCode();

});

}

}

结果如下：

java8的foreach依然不负众望，最快的是增强for循环。

+最终结论

普通(数量级10W以下，非并行)遍历一个集合(List、Set、Map)如果在意效率，不要使用java8的foreach，虽然它很方便很优雅

任何时候使用增强for循环是你不二的选择

为什么阿里巴巴禁止在 foreach 循环里进行元素的 remove&sol;add 操作--java&period;util&period;ConcurrentModificationException

摘要 foreach循环(Foreach loop)是计算机编程语言中的一种控制流程语句,通常用来循环遍历数组或集合中的元素. 在阿里巴巴Java开发手册中,有这样一条规定: 但是手册中并没有给出具体 ...

为什么禁止在 foreach 循环里进行元素的 remove&sol;add 操作

首先看下边一个例子,展示了正确的做法和错误的错发: 这是为什么呢,具体原因下面进行详细说明: 1.foreach循环(Foreach loop)是计算机编程语言中的一种控制流程语句,通常用来循环遍历数 ...

有关集合的foreach循环里的add&sol;remove

转自:Hollis(微信号:hollischuang) 在阿里巴巴Java开发手册中,有这样一条规定: 但是手册中并没有给出具体原因,本文就来深入分析一下该规定背后的思考. 1 .foreach循环 ...

禁止foreach循环使用remove&sol;add----快速失败

阿里巴巴开发手册中有一条: 7[强制]不要在 foreach 循环里进行元素的 remove / add 操作. remove 元素请使用 Iterator 方式,如果并发操作,需要对 Iterato ...

&lbrack;Java8教程&rsqb;Java8新特性进阶集合

Java8新特性进阶集合 基于 AOP 抽离方法的重复代码 Java8:当 Lambda 遇上受检异常 Java8:对字符串连接的改进 Java8:Java8 中 Map 接口的新方法 Java8:当 ...

JAVA中的for-each循环与迭代

在学习java中的collection时注意到,collection层次的根接口Collection实现了Iterable接口(位于java.lang包中),实现这个接口允许对象成为 ...

foreach循环 Java

第一次遇到foreach循环,是在PHP的数组中,同样,在Java数组中,也遇到了foreach循环,都是用来遍历数组(集合).遍历数组,首先想到的一般都是用while,do while,for循环, ...

集合框架遍历方式之——for-each循环

从Java5起,在Java中有了for-each循环,可以用来循环遍历collection和array.Foreach循环允许你在无需保持传统for循环中的索引,或在使用iterator /ListI ...

Java语法糖1：可变长度参数以及foreach循环原理

语法糖 接下来几篇文章要开启一个Java语法糖系列,所以首先讲讲什么是语法糖.语法糖是一种几乎每种语言或多或少都提供过的一些方便程序员开发代码的语法,它只是编译器实现的一些小把戏罢了,编译期间以特定的 ...

巧用array&lowbar;map&lpar;&rpar;和array&lowbar;reduce&lpar;&rpar;替代foreach循环

1.array_reduce( $arr , callable $callback ) 使用回调函数迭代地将数组简化为单一的值. 其中$arr 为输入数组,$callback($result , $v ...

随机推荐

ZeroMQ接口函数之 ：zmq&lowbar;curve&lowbar;keypair - 生成一个新的CURVE 密钥对

ZeroMQ 官方地址 :http://api.zeromq.org/4-0:zmq_curve_keypair zmq_curve_keypair(3) ØMQ Manual - ØMQ/4.1.0 ...

java中开源日志记录工具log4j

日志:除了能记录异常信息,还可以记录程序正常运行时的关键信息. 使用log4j来进行日志文件记录经典步骤: 001.在项目中创建一个lib文件夹,然后将下载好的jar包copy到该文件夹下 002.对 ...

集合迭代器快速失败行为及CopyOnWriteArrayList

以下内容基于jdk1.7.0_79源码: 什么是集合迭代器快速失败行为 以ArrayList为例,在多线程并发情况下,如果有一个线程在修改ArrayList集合的结构(插入.移除...),而另一个线程 ...

BootStrap2学习日记22---点击展开

先看效果: Code: