java各种List循环：性能效率对比

测试电脑：2核8G内存
10000条数据
执行结果：
第一次：
stream parallel forEach:488
增强for:1100
Iterator:1223
普通 forEach:1231
stream forEach:1234
普通 for:1295

第二次：
stream parallel forEach:533
stream forEach:1162
普通 forEach:1206
普通 for:1335
增强for:1351
Iterator:1359

第三次：
stream parallel forEach:558
增强for:1546
stream forEach:1551
普通 forEach:1565
普通 for:1575
Iterator:1599

第四次：
stream parallel forEach:576
增强for:1569
stream forEach:1478
Iterator:1487
普通 forEach:1488
普通 for:1495

第五次：
stream parallel forEach:476
普通 forEach:1056
Iterator:1093
stream forEach:1196
普通 for:1257
增强for:1274

总结：明显stream parallel 的性能好和很多，但它是线程不安全的，在并行不考虑顺序，任务之间无依懒时可以考虑使用stream parallel。
其它循环对比差距不大，增强for循环相对来其它几种略有优势。
(个人兴趣测试，可能还有其它因素没考虑到，无权威性可言)

原文链接：https://blog.csdn.net/andy_only/article/details/98597094

public final class JSONUtil{
	 public static <T> T readValue(String content, Class<T> valueType) {
        if (content == null) {
            return null;
        }
        T result = null;
       ObjectMapper  objectMapper = new ObjectMapper();
        try {
            result = objectMapper.readValue(content, valueType);
        } catch (IOException e) {
            throw new RuntimeException("write json error", e);
        }
        return result;
    }
	public static void main(String[] args) {
	    //造点数据，10万条json
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add("{\"mame\":\"wwq1\",\"age\":"+i+"}");
        }
        //避免jvm预热影响，这里使用线程池测试
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //所有循环内容一致，遍历List<String>,json对象转map,添加到新的List<Map>
        executorService.submit(()->{
            long t4 = System.currentTimeMillis();
            List<Map> mlist4 = new ArrayList<>();
            list.stream().parallel().forEach(s->{
                Map map = readValue(s, Map.class);
                mlist4.add(map);
            });
            System.out.println("stream parallel forEach:"+(System.currentTimeMillis()-t4));
        });
        executorService.submit(()->{
            long t0 = System.currentTimeMillis();
            List<Map> mlist0 = new ArrayList<>();
            for (int i = 0; i <list.size(); i++) {
                String s = list.get(i);
                Map map = readValue(s, Map.class);
                mlist0.add(map);
            }
            System.out.println("普通 for:"+(System.currentTimeMillis()-t0));
        });


        executorService.submit(()->{
            long t1 = System.currentTimeMillis();
            List<Map> mlist1 = new ArrayList<>();
            for(String s:list){
                Map map = readValue(s, Map.class);
                mlist1.add(map);
            }
            System.out.println("增强for:"+(System.currentTimeMillis()-t1));
        });

        executorService.submit(()->{
            long t3 = System.currentTimeMillis();
            List<Map> mlist3 = new ArrayList<>();
            list.forEach(s->{
                Map map = readValue(s, Map.class);
                mlist3.add(map);
            });
            System.out.println("普通 forEach:"+(System.currentTimeMillis()-t3));
        });
        executorService.submit(()->{
            long t2 = System.currentTimeMillis();
            List<Map> mlist2 = new ArrayList<>();
            list.stream().forEach(s->{
                Map map = readValue(s, Map.class);
                mlist2.add(map);
            });
            System.out.println("stream forEach:"+(System.currentTimeMillis()-t2));
        });
        executorService.submit(()->{
            long t5 = System.currentTimeMillis();
            List<Map> mlist5 = new ArrayList<>();
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()){
                String s = iterator.next();
                Map map = readValue(s, Map.class);
                mlist5.add(map);
            }
            System.out.println("Iterator:"+(System.currentTimeMillis()-t5));
        });
        executorService.shutdown();
	 }
}