for-each循环是jdk1.5引入的新的语法功能。并不是所有东西都可以使用这个循环的。可以看下Iterable接口的注释，它说明了除了数组外，其他类想要使用for-each循环必须实现这个接口。这一点表明除了数组外的for-each可能底层是由迭代器实现的。
Iterable接口在1.8之前只有一个方法,Iterator<T> iterator()，此方法返回一个迭代器。由于更早出现的Collection接口中早就有了这个同样的方法，所以只需要让Collection接口继承Iterable接口，基于Collection的集合类就可以不做任何更改就使用for-each循环。
对于数组，因为数组不实现Iterable接口，它的for-each实现原理应该和Collection不一样。
下面就通过分析下不同方式编译后的字节码，简单研究下for-each的的底层原理。
一、数组的for-each
下面是的两个很简单的类，可以看出它们的功能是一样的。Java环境使用的是jdk1.8_111。
1. package iter;
2.
3. public class TestArray {
4. public static void main(String[] args) {
5. //String[] a = {"a", "b", "c"};
6. long[] a = {2L, 3L, 5L};
7. for (long i : a) {
8. System.err.println(i);
9. }
10. }
11. }
用javap -c看下两个类的字节码操作，保存成了文本，具体情况如下。
1. Compiled from "TestArrayFor.java"
2. public class iter.TestArrayFor {
3. public iter.TestArrayFor();
4. Code:
5. 0: aload_0
6. 1: invokespecial #8 // Method java/lang/Object."<init>":()V
7. 4: return
8.
9. public static void main(java.lang.String[]);
10. Code:
11. 0: iconst_3
12. 1: newarray long
13. 3: dup
14. 4: iconst_0
15. 5: ldc2_w #16 // long 2l
16. 8: lastore
17. 9: dup
18. 10: iconst_1
19. 11: ldc2_w #18 // long 3l
20. 14: lastore
21. 15: dup
22. 16: iconst_2
23. 17: ldc2_w #20 // long 5l
24. 20: lastore
25. 21: astore_1 /* 0-21行，创建long数组a，并保存在线程的当前栈帧的局部变量表的第1格*/
26. 22: iconst_0 /* 读取数字0（这个就是普通的0）到栈中 */
27. 23: istore_2 /* 将栈顶的数字0保存在第二个，22-23就是执行int i = 0; */
28. 24: aload_1 /* 读取保存在线程的当前栈帧的局部变量表的第1格的对象的引用，就是读取数组a */
29. 25: arraylength /* 获取数组长度a.length */
30. 26: istore_3 /* 把数组长度保存在线程的当前栈帧的局部变量表的第3格，24-26就是执行int len = a.length */
31. 27: goto 42 /* 无条件跳到标记42的那个地方，开始循环的代码 */
32. 30: getstatic #22 // Field java/lang/System.err:Ljava/io/PrintStream; /* 获取类的static属性，就是System.err */
33. 33: aload_1 /* 读取数组a */
34. 34: iload_2 /* 读取i */
35. 35: laload /* 读取a[i] */
36. 36: invokevirtual #28 // Method java/io/PrintStream.println:(J)V /* 执行虚拟机方法，30-36就是执行System.err.println(a[i]) */
37. 39: iinc 2, 1 /* 将第2格的数字加1，就是执行i++ */
38. 42: iload_2 /* 读取i */
39. 43: iload_3 /* 读取len */
40. 44: if_icmplt 30 /* 如果i < len，跳到标记30的那个地方，不满足就往下 */
41. 47: return
42. }
通过编译后的字节码可以看出，数组的for-each和普通的for循环底层原理是一样的，都是用的普通for循环的那一套。数组的for-each比普通for循环多一点点操作，理论上是要慢一点点，这个暂时也不知道是为什么。这也是语法糖的一些代价，语法越简单，反而越不好进行底层优化。不过这个慢一点那真是一点，在循环体比较复杂时，这个差距就更小了，所以基本上可以认为这两种方式效率一样。实际中根据自己的情况选择，如果需要显式使用下标，就用传统for循环，其他的都可以使用for-each循环。
二、Collection的for-each
还是先贴两段简单的对比的代码，代码逻辑一样。Java环境使用的是jdk1.8_111。
1. package iter;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5.
6. public class TestFor {
7. public static void main(String[] args) {
8. new ArrayList<String>();
9. for(String str : listA) {
10. System.err.println(str);
11. }
12. }
13. }
还是跟数组的一样分析，贴下编译后的字节码。
1. Compiled from "TestFor.java"
2. public class iter.TestFor {
3. public iter.TestFor();
4. Code:
5. 0: aload_0
6. 1: invokespecial #8 // Method java/lang/Object."<init>":()V
7. 4: return
8.
9. public static void main(java.lang.String[]);
10. Code:
11. 0: new #16 // class java/util/ArrayList
12. 3: dup
13. 4: invokespecial #18 // Method java/util/ArrayList."<init>":()V
14. 7: astore_1
15. 8: aload_1
16. 9: invokeinterface #19, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
17. 14: astore_3
18. 15: goto 35
19. 18: aload_3
20. 19: invokeinterface #25, 1 // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
21. 24: checkcast #31 // class java/lang/String
22. 27: astore_2
23. 28: getstatic #33 // Field java/lang/System.err:Ljava/io/PrintStream;
24. 31: aload_2
25. 32: invokevirtual #39 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
26. 35: aload_3
27. 36: invokeinterface #45, 1 // InterfaceMethod java/util/Iterator.hasNext:()Z
28. 41: ifne 18
29. 44: return
30. }
这两段字节码中自带的注释很多，基本上看得懂，就不添加注释了。
两段字节码除了几个变量保存在线程的当前栈帧的局部变量表的索引（astore_n，这个n就是索引）不一样外，其余的都是一模一样的。不排除某次编译后连那几个索引值也一样，那就真一模一样了。字节码自带的注释都说了，Collection的for-each底层也是使用迭代器来实现的，两种方式可以说是完全等价的。
对于实现了RandomAccess接口的实现类，因为它们的随机访问操作的时间复杂度为O(1)，大多数情况使用传统for循环会比用迭代器循环（这里的迭代器也可以用for-each替换，上面说了它们底层整体是一样的）要快。至于这一点是为什么，可以看下ArrayList的源码。它的迭代器虽然也是通过下标直接访问elementData数组，但是迭代器多了很多方法调用以及其他的额外操作，现在很多编译器cpu也都会对传统for循环进行特别的优化，在这个层面十几个指令的差别就很大了，这些因素加在一起导致RandomAccess的迭代器比传统for循环要慢一些。对于ArrayList这种，在cpu密集型的应用中应该只使用传统for循环，在循环体执行时间比较长的应用中，传统for循环和迭代器循环的差别就很小了，这时候使用迭代器（for-each循环）也不会明显降低执行效率。
参考：
1、https://docs.oracle.com/javase/8/docs/technotes/guides/language/foreach.html
2、Java虚拟机规范（Java SE 8）
