无论是数组的循环遍历，或者是列表的循环遍历，在实际工程中都是十分常见的。对于java来说，除了常见的for循环之外，还有所谓的foreach，即增强型for循环。在对两者进行比较之前，先介绍一下foreach的底层原理。
       foreach本质上是java中的语法糖，对数组操作时，底层原理和普通的for循环一样；而对列表操作时，实际上是采用了迭代器的方法。下面我们分别对数组int[]以及两种列表类型ArrayList和LinkedList进行时间测试，代码如下所示：

import java.util.*;
public class Main {
    private static int length = 100000;
    private static int number = 10;
    public static void main(String[] args) {
        int[] array = new int[length];
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new LinkedList<>();
        for (int i = 0; i < length; i++) {
            list1.add(i);
            list2.add(i);
        }
        long[] times = new long[6];
        for (int i = 0; i < number; i++) {
            times[0] += forArrayTime(array);
            times[1] += foreachArrayTime(array);
            times[2] += forListTime(list1);
            times[3] += foreachListTime(list1);
            times[4] += forListTime(list2);
            times[5] += foreachListTime(list2);
        }
        System.out.println(String.format("for循环执行数组int[]的时间为：%s", times[0]/10));
        System.out.println(String.format("foreach执行数组int[]的时间为：%s", times[1]/10));
        System.out.println(String.format("for循环执行ArrayList的时间为：%s", times[2]/10));
        System.out.println(String.format("foreach执行ArrayList的时间为：%s", times[3]/10));
        System.out.println(String.format("for循环执行LinkedList的时间为：%s", times[4]/10));
        System.out.println(String.format("foreach执行LinkedList的时间为：%s", times[5]/10));
    }

    private static long forArrayTime(int[] array) {
        long start = System.nanoTime();
        for (int i = 0; i < length; i++) {
            testTime(array[i]);
        }
        return System.nanoTime() - start;
    }

    private static long foreachArrayTime(int[] array) {
        long start = System.nanoTime();
        for (int i : array) {
            testTime(i);
        }
        return System.nanoTime() - start;
    }

    private static long forListTime(List<Integer> list) {
        long start = System.nanoTime();
        for (int i = 0; i < length; i++) {
            testTime(list.get(i));
        }
        return System.nanoTime() - start;
    }

    private static long foreachListTime(List<Integer> list) {
        long start = System.nanoTime();
        for (int i : list) {
            testTime(i);
        }
        return System.nanoTime() - start;
    }

    private static void testTime(Integer num) {}
}

运行10次取平均值，输出结果如下：

for循环执行数组int[]的时间为：263990
foreach执行数组int[]的时间为：809164
for循环执行ArrayList的时间为：1371229
foreach执行ArrayList的时间为：1993637
for循环执行LinkedList的时间为：6154382234
foreach执行LinkedList的时间为：1197516

       可以看出，对于数组和数组列表而言，for循环比foreach的执行效率稍高。但对于随机读取比较慢的链表而言，迭代器模式的foreach比for循环要快得多。如果不考虑速度的影响，foreach的优点是代码的可读性更强，但缺点是没有索引，在需要索引操作时候显得很不方便。