这是一个等价的表达式。

for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
    System.out.println(sit.next());
}

foreach循环语法为：

for (type obj:array) {...}

例子：

String[] s = {"Java", "Coffe", "Is", "Cool"};
for (String str:s /*s is the array*/) {
    System.out.println(str);
}

输出：

Java
Coffe
Is
Cool

警告：可以使用foreach循环访问数组元素，但不能初始化它们。为此使用原始for循环。

警告：必须将数组的类型与其他对象匹配。

for (double b:s) // Invalid-double is not String

如果要编辑元素，请使用原始for循环，如下所示：

for (int i = 0; i < s.length-1 /*-1 because of the 0 index */; i++) {
    if (i==1) //1 because once again I say the 0 index
        s[i]="2 is cool";
    else
        s[i] = "hello";
}

现在，如果我们将数据转储到控制台，我们会得到：

hello
2 is cool
hello
hello

Java for each循环（也称为增强的for循环）是for循环的简化版本。优点是编写的代码更少，管理的变量更少。缺点是无法控制步长值，也无法访问循环体中的循环索引。

当阶跃值是简单的1增量，并且您只需要访问当前循环元素时，最好使用它们。例如，如果需要在数组或集合中的每个元素上循环，而不在当前元素的前面或后面偷看。

没有循环初始化，没有布尔条件，步长值是隐式的，是一个简单的增量。这就是为什么它们被认为比常规for循环简单得多。

增强的for循环遵循以下执行顺序：

1） 环形体

2） 从步骤1开始重复，直到遍历了整个数组或集合

示例–整数数组

int [] intArray = {1, 3, 5, 7, 9};
for(int currentValue : intArray) {
  System.out.println(currentValue);
}

currentValue变量保存在intArray数组中循环的当前值。请注意，没有显式的步长值——它总是以1为增量。

冒号可以被认为是“in”的意思。因此，增强的for循环声明声明：循环intArray并将当前数组int值存储在currentValue变量中。

输出：

1
3
5
7
9

示例–字符串数组

我们可以使用for each循环遍历字符串数组。循环声明声明：循环myStringsString数组并将当前String值存储在currentString变量中。

String [] myStrings  = {
  "alpha",
  "beta",
  "gamma",
  "delta"
};

for(String currentString : myStrings) {
  System.out.println(currentString);
}

输出：

alpha
beta
gamma
delta

示例–列表

增强的for循环还可以用于迭代java.util.List，如下所示：

List<String> myList = new ArrayList<String>();
myList.add("alpha");
myList.add("beta");
myList.add("gamma");
myList.add("delta");

for(String currentItem : myList) {
  System.out.println(currentItem);
}

循环声明声明：循环myList List of Strings并将当前List值存储在currentItem变量中。

输出：

alpha
beta
gamma
delta

示例–集合

增强的for循环还可以用于迭代java.util.Set，如下所示：

Set<String> mySet = new HashSet<String>();
mySet.add("alpha");
mySet.add("alpha");
mySet.add("beta");
mySet.add("gamma");
mySet.add("gamma");
mySet.add("delta");

for(String currentItem : mySet) {
  System.out.println(currentItem);
}

循环声明声明：循环mySet字符串集，并将当前Set值存储在currentItem变量中。注意，因为这是一个Set，所以不会存储重复的String值。

输出：

alpha
delta
beta
gamma

来源：Java中的循环–终极指南

代码应为：

import java.util.ArrayList;
import java.util.List;

public class ForLoopDemo {

  public static void main(String[] args) {

    List<String> someList = new ArrayList<String>();

    someList.add("monkey");
    someList.add("donkey");
    someList.add("skeleton key");

    // Iteration using For Each loop
    System.out.println("Iteration using a For Each loop:");
    for (String item : someList) {
      System.out.println(item);
    }

    // Iteration using a normal For loop
    System.out.println("\nIteration using normal For loop: ");
    for (int index = 0; index < someList.size(); index++) {
      System.out.println(someList.get(index));
    }
  }
}

每个习惯用法的Java只能应用于*Iterable类型的数组或对象。这个习惯用法是隐含的，因为它确实有迭代器支持。迭代器由程序员编程，通常使用整数索引或节点（取决于数据结构）来跟踪其位置。从理论上讲，它比常规的for循环慢，至少对于数组和列表等“线性”结构来说是这样，但它提供了更大的抽象性。

正如许多好答案所说，如果一个对象想要使用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循环时会抛出异常。