java中常用list用哪种遍历方式最快

1. ArrayList
   ArrayList的底层是数组，是一块连续的内存，特点是可以通过索引直接定位到元素。
   现在说结论：
   用迭代器或者list的forEach效率比较好，
2. LinkedList
   LinkedList的底层是链表，在内存中是不连续的，不能通过索引直接定位到袁旭，需要从头开始遍历。
   现在说结论：不能使用list.get(i),这样特别耗时。效率比较好的话：使用用迭代器或者list的forEach效率比较好。

现在贴上测试的代码

 public static void main(String[] args) {
       List<String> uuids = new ArrayList<>();
        for (int i = 0; i < 1000000; i++) {
            String  uuid = UUID.fastUUID().toString(true);
            uuids.add(uuid);
        }

        for (int i = 0; i < 10; i++) {
            System.out.println("------------------------第 " + (i + 1) + " 次 loop------------");
            StopWatch watch1 = new StopWatch();
            watch1.start();
            loop1(uuids);
            watch1.stop();
            System.out.println("loop1 耗时： " + watch1.getTotalTimeMillis());

            StopWatch watch2 = new StopWatch();
            watch2.start();
            loop2(uuids);
            watch2.stop();
            System.out.println("loop2 耗时： " + watch2.getTotalTimeMillis());

            StopWatch watch3 = new StopWatch();
            watch3.start();
            loop3(uuids);
            watch3.stop();
            System.out.println("loop3 耗时： " + watch3.getTotalTimeMillis());

            StopWatch watch4 = new StopWatch();
            watch4.start();
            loop4(uuids);
            watch4.stop();
            System.out.println("loop4 耗时： " + watch4.getTotalTimeMillis());

            StopWatch watch5 = new StopWatch();
            watch5.start();
            loop5(uuids);
            watch5.stop();
            System.out.println("loop5 耗时： " + watch5.getTotalTimeMillis());

            StopWatch watch6 = new StopWatch();
            watch6.start();
            loop6(uuids);
            watch6.stop();
            System.out.println("loop6 耗时： " + watch6.getTotalTimeMillis());
        }

    }
    public static void loop1(List<String> uuids) {
        List<String> result =new ArrayList<>(uuids.size());
        uuids.stream().forEach(item -> result.add(item));
        System.out.println("loop1 result size: " + result.size());
    }


    public static void loop2(List<String> uuids) {
        List<String> result =new ArrayList<>(uuids.size());
        uuids.stream().parallel().forEach(item -> {
            result.add(item);
        });
        System.out.println("loop2 result size: " + result.size());
    }

    public static void loop3(List<String> uuids) {
        List<String> result = new ArrayList<>(uuids.size());
        for(String item : uuids){
            result.add(item);
        }
        System.out.println("loop3 result size: " + result.size());
    }

    public static void loop4(List<String> uuids) {
        List<String> result = new ArrayList<>(uuids.size());
        for(int j = 0; j < uuids.size(); j ++){
            result.add(uuids.get(j));
        }
        System.out.println("loop4 result size: " + result.size());
    }

    public static void loop5(List<String> uuids) {
        List<String> result =new ArrayList<>(uuids.size());
        uuids.forEach( s -> result.add(s));
        System.out.println("loop5 result size: " + result.size());
    }

    public static void loop6(List<String> uuids) {
        List<String> result =new ArrayList<>(uuids.size());
        Iterator<String> iterator = uuids.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            result.add(next);
        }
        System.out.println("loop6 result size: " + result.size());
    }