正如许多其他答案正确指出的那样，for each循环只是同一个旧for循环的语法糖，编译器将其转换为同一个老for循环。

javac（OpenJDK）有一个开关-XD printflat，它生成一个Java文件，去掉了所有语法糖。完整的命令如下所示：

javac -XD-printflat -d src/ MyFile.java

//-d is used to specify the directory for output java file

所以让我们去掉语法糖

为了回答这个问题，我创建了一个文件，并为每个文件编写了两个版本，一个带有数组，另一个带有列表。我的Java文件如下所示：

import java.util.*;

public class Temp{

    private static void forEachArray(){
        int[] arr = new int[]{1,2,3,4,5};
        for(int i: arr){
            System.out.print(i);
        }
    }

    private static void forEachList(){
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        for(Integer i: list){
            System.out.print(i);
        }
    }
}

当我用上面的开关编译这个文件时，我得到了以下输出。

import java.util.*;

public class Temp {

    public Temp() {
        super();
    }

    private static void forEachArray() {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        for (/*synthetic*/ int[] arr$ = arr, len$ = arr$.length, i$ = 0; i$ < len$; ++i$) {
            int i = arr$[i$];
            {
                System.out.print(i);
            }
        }
    }

    private static void forEachList() {
        List list = Arrays.asList(new Integer[]{Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3), Integer.valueOf(4), Integer.valueOf(5)});
        for (/*synthetic*/ Iterator i$ = list.iterator(); i$.hasNext(); ) {
            Integer i = (Integer)i$.next();
            {
                System.out.print(i);
            }
        }
    }
}

您可以看到，与其他语法糖（Autoboxing）一起，每个循环都被更改为简单循环。

for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
    String item = i.next();
    System.out.println(item);
}

注意，如果需要使用i.remove（）；在循环中，或者以某种方式访问实际的迭代器，不能使用for（：）习惯用法，因为实际的迭代器只是推断出来的。

正如Denis Bueno所指出的，这段代码适用于实现Iterable接口的任何对象。

此外，如果for（：）习惯用法的右侧是数组而不是Iterable对象，则内部代码使用int索引计数器并检查array.length。请参阅Java语言规范。

如JLS中所定义的，每个循环的a可以有两种形式：

如果表达式类型是Iterable的子类型，则转换为：List<String>someList=newArrayList<String>（）；someList.add（“苹果”）；someList.add（“球”）；for（字符串项：someList）{System.out.println（项）；}//翻译为：for（Iterator<String>stringIterator=someList.iiterator（）；stringIterator.hasNext（）；）{字符串项=stringIterator.next（）；System.out.println（项）；}如果表达式必须具有数组类型T[]，则：String[]someArray=新字符串[2]；someArray[0]=“苹果”；someArray[1]=“球”；for（字符串项2:someArray）{系统输出打印（第2项）；}//翻译为：for（int i=0；i<someArray.length；i++）{字符串item2=someArray[i]；系统输出打印（第2项）；}

Java8已经引入了一些流，这些流在适当大小的数据集中通常表现得更好。我们可以将它们用作：

someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);

它消除了所有基本的循环混乱，为代码增添了美感。它为您的代码提供了一个干净的外观，如下所示。

循环正常：

void cancelAll(Collection<TimerTask> list) {
    for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
         i.next().cancel();
}

用于每个：

void cancelAll(Collection<TimerTask> list) {
    for (TimerTask t : list)
        t.cancel();
}

for each是实现Iterator的集合上的构造。记住，您的集合应该实现Iterator；否则，不能将其用于每个。

以下行读作“for each TimerTask t in list”

for (TimerTask t : list)

每种情况下出现错误的可能性较小。您不必担心初始化迭代器或初始化循环计数器并终止它（在存在错误的地方）。

在Java 8之前，您需要使用以下功能：

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
    String item = iterator.next();
    System.out.println(item);
}

然而，通过在Java8中引入Streams，您可以用更少的语法完成同样的任务。例如，对于someList，您可以执行以下操作：

someList.stream().forEach(System.out::println);

你可以在这里找到更多关于溪流的信息。

正如许多好答案所说，如果一个对象想要使用for each循环，它必须实现Iterable接口。

我将发布一个简单的示例，并尝试以不同的方式解释for each循环的工作原理。

对于每个循环示例：

public class ForEachTest {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("222");

        for (String str : list) {
            System.out.println(str);
        }
    }
}

然后，如果我们使用javap来反编译这个类，我们将得到这个字节码示例：

public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: new           #16                 // class java/util/ArrayList
         3: dup
         4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
         7: astore_1
         8: aload_1
         9: ldc           #19                 // String 111
        11: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
        16: pop
        17: aload_1
        18: ldc           #27                 // String 222
        20: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
        25: pop
        26: aload_1
        27: invokeinterface #29,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;

从示例的最后一行可以看到，编译器将在编译时自动将for每个关键字的使用转换为Iterator的使用。这可以解释为什么对象（它没有实现Iterable接口）在尝试使用for each循环时会抛出异常。