Java 'for each' 循环是如何工作的？
Posted
技术标签:
【中文标题】Java \'for each\' 循环是如何工作的？【英文标题】：How does the Java 'for each' loop work?Java 'for each' 循环是如何工作的？ 【发布时间】：2016-03-02 00:51:40 【问题描述】：考虑：
List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList)
System.out.println(item);
如果不使用 for each 语法，等效的 for 循环会是什么样子？
【问题讨论】：
根据 JLS，它有两种形式：***.com/a/33232565/1216775 Java for 循环有多种类型，如下所述。对于所有类型，for 循环的工作方式都是相同的，仅在语法上有所不同。 * 简单的 for 循环 (tutorialcup.com/java/…) * 增强的 for 循环 – 用于每个循环 (tutorialcup.com/java/java-for-loop.htm#Enhanced_Java_For_loop) * 嵌套的 for 循环 (tutorialcup.com/java/java-for-loop.htm#Nested_For_Loop) * 标记的 for 循环 (tutorialcup.com/java/java-for-loop.htm#Labeled_For_loop) tutorialcup.com/java/java-for-loop.htm 我们可以使用增强的for循环来迭代以下集合的元素：Array ArrayList Map Set LinkedList 等等。 tutorialcup.com/java/java-for-each-loop.htm 【参考方案1】：for (Iterator<String> i = someIterable.iterator(); i.hasNext();)
String item = i.next();
System.out.println(item);
请注意，如果您需要在循环中使用i.remove();，或以某种方式访问实际的迭代器，则不能使用for ( : ) 成语，因为实际的迭代器只是推断出来的。
正如 Denis Bueno 所指出的，此代码适用于任何实现 Iterable interface 的对象。
此外，如果 for (:) 惯用语的右侧是 array 而不是 Iterable 对象，则内部代码使用 int 索引计数器并改为检查 array.length。见Java Language Specification。
【讨论】：
我发现只是调用了像 while (someList.hasMoreElements()) //do something 这样的 while 循环 - 让我接近了我的编码优雅'd希望在我搜索这个问题时找到。【参考方案2】：构造for each 也适用于数组。例如
String[] fruits = new String[] "Orange", "Apple", "Pear", "Strawberry" ;
for (String fruit : fruits)
// fruit is an element of the `fruits` array.
本质上相当于
for (int i = 0; i < fruits.length; i++)
String fruit = fruits[i];
// fruit is an element of the `fruits` array.
所以，总体总结：[nsayer] 以下是正在发生的事情的较长形式：
for(Iterator<String> i = someList.iterator(); i.hasNext(); ) String item = i.next(); System.out.println(item);请注意，如果您需要使用 i.remove();在您的循环中，或访问 以某种方式实际的迭代器，你 不能使用 for( : ) 成语，因为 实际的迭代器仅仅是 推断。
[Denis Bueno]
nsayer 的回答暗示了这一点，但是 值得注意的是，OP 的 for(..) 当“someList”为 任何实现 java.lang.Iterable -- 它没有 成为一个列表，或者某个集合 java.util.甚至你自己的类型， 因此，可以与此一起使用 语法。
【讨论】：
我不会说第二个示例“基本上等同于第一个”，因为如果它是一个原始值列表，那么您对这些值所做的任何修改都不会修改示例 1 中的原始列表，但会修改示例 2 中的原始列表。【参考方案3】：Java 5 中添加的for-each loop（也称为“增强的 for 循环”）相当于使用 java.util.Iterator——它是同一事物的语法糖。因此，在逐个按顺序读取每个元素时，应该始终选择 for-each 而不是迭代器，因为它更方便和简洁。
对于每个
for (int i : intList)
System.out.println("An element in the list: " + i);
迭代器
Iterator<Integer> intItr = intList.iterator();
while (intItr.hasNext())
System.out.println("An element in the list: " + intItr.next());
在某些情况下，您必须直接使用Iterator。例如，在使用 for-each 时尝试删除元素可以（会？）导致ConcurrentModificationException。
for-each 与 for-loop：基本区别
for-loop 和 for-each 之间的唯一实际区别是，对于可索引对象，您无权访问索引。需要基本 for 循环的示例：
for (int i = 0; i < array.length; i++)
if(i < 5)
// Do something special
else
// Do other stuff
虽然您可以使用 for-each 手动创建单独的索引 int 变量，
int idx = -1;
for (int i : intArray)
idx++;
...
...不推荐，因为variable-scope 并不理想，基本的for 循环只是此用例的标准和预期格式。
for-each 与 for-loop：性能
访问集合时，for-each 是 significantly faster，而不是基本的 for 循环的数组访问。然而，在访问数组时——至少使用原始数组和包装数组——通过索引进行访问要快得多。
原始 int 数组的迭代器和索引访问之间的时间差异
在访问 int 或 Integer 数组时，索引比迭代器快 23-40%。这是本文底部测试类的输出，它对 100 个元素的原始整数数组中的数字求和（A 是迭代器，B 是索引）：
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)
我还为 Integer 数组运行了这个，索引仍然是明显的赢家，但速度仅提高了 18% 到 25%。
对于集合，迭代器比索引快
然而，对于Integers 中的List，迭代器显然是赢家。只需将测试类中的 int-array 更改为：
List<Integer> intList = Arrays.asList(new Integer[] 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100);
并对测试功能进行必要的更改（int[] 到 List<Integer>、length 到 size() 等）：
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)
在一项测试中，它们几乎是等价的，但对于集合，迭代器胜出。
*这篇文章基于我在 Stack Overflow 上写的两个答案：
Uses and syntax for for-each loop in Java
Should I use an Iterator or a forloop to iterate?
更多信息：Which is more efficient, a for-each loop, or an iterator?
完整的测试类
在阅读 Stack Overflow 上的 this question 后，我创建了这个 compare-the-time-it-takes-to-do-any-two-things 类：
import java.text.NumberFormat;
import java.util.Locale;
/**
<P>@code java TimeIteratorVsIndexIntArray 1000000</P>
@see <CODE><A HREF="https://***.com/questions/180158/how-do-i-time-a-methods-execution-in-java">https://***.com/questions/180158/how-do-i-time-a-methods-execution-in-java</A></CODE>
**/
public class TimeIteratorVsIndexIntArray
public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);
public static final void main(String[] tryCount_inParamIdx0)
int testCount;
// Get try-count from a command-line parameter
try
testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
catch(ArrayIndexOutOfBoundsException | NumberFormatException x)
throw new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
//Test proper...START
int[] intArray = new int[] 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100;
long lStart = System.nanoTime();
for(int i = 0; i < testCount; i++)
testIterator(intArray);
long lADuration = outputGetNanoDuration("A", lStart);
lStart = System.nanoTime();
for(int i = 0; i < testCount; i++)
testFor(intArray);
long lBDuration = outputGetNanoDuration("B", lStart);
outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
private static final void testIterator(int[] int_array)
int total = 0;
for(int i = 0; i < int_array.length; i++)
total += int_array[i];
private static final void testFor(int[] int_array)
int total = 0;
for(int i : int_array)
total += i;
//Test proper...END
//Timer testing utilities...START
public static final long outputGetNanoDuration(String s_testName, long l_nanoStart)
long lDuration = System.nanoTime() - l_nanoStart;
System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
return lDuration;
public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName)
long lDiff = -1;
double dPct = -1.0;
String sFaster = null;
if(l_aDuration > l_bDuration)
lDiff = l_aDuration - l_bDuration;
dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
sFaster = "B";
else
lDiff = l_bDuration - l_aDuration;
dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
sFaster = "A";
System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
return lDiff;
//Timer testing utilities...END
【讨论】：
这个答案现在是 blog post，是根据我写的两个相关答案创建的：here 和 here。它还包括一个通用的类，用于比较两个函数的速度（在底部）。 这里只是一个小评论，你不应该断然声明 for(:) 语法总是更适合访问集合；如果您使用的是数组列表，for (:) 循环将比使用 for (int i = 0, len = arrayList.size(); i ***.com/questions/2113216/…) 链接中提到了这一点，但强调这一点很重要...... 我认为for(int value : int_array) /* loop content */ 在您的测试中是最慢的，因为它在语法上等同于 for(int i = 0; i < int_array.length; i++) int value = int_array[i]; /* loop content */，这不是您的测试所比较的。
在这里比较苹果对苹果很重要。问题是关于for 与foreach。您正在比较索引访问与迭代访问。重要的是要指出 foreach 只是语法糖包装“迭代器”遍历集合。当您始终使用迭代器时，for 和 foreach 之间没有明显的区别，因此暗示 foreach 性能更好是不公平的。从技术上讲，它生成与常规 for 循环相同的代码前提是您仍在 for 循环中使用迭代器。
对我来说说 foreach 在通过 Collection 时性能更高是非常误导的。如果它是使用 get(i) 的 for 循环中的链表，则您不会遍历一次，而是遍历 1+2+..n 次。使用 iterable 是为了确保以最优化的方式遍历 Collection，而不必编写额外的代码（例如：current = current.getChild()）。当然，对于 ArrayList，使用 for 而不是 fo foreach 会快一些，因为您不需要构造中间迭代器。对我来说，在这种情况下，合乎逻辑的解释比基准要好得多【参考方案4】：
这是一个不假设 Java 迭代器知识的答案。它不太精确，但对教育很有用。
在编程时，我们经常编写如下代码：
char[] grades = ....
for(int i = 0; i < grades.length; i++) // for i goes from 0 to grades.length
System.out.print(grades[i]); // Print grades[i]
foreach 语法允许这种通用模式以更自然且语法噪音更少的方式编写。
for(char grade : grades) // foreach grade in grades
System.out.print(grade); // print that grade
此外，此语法对于不支持数组索引但实现 Java Iterable 接口的对象（例如 Lists 或 Sets）有效。
【讨论】：
【参考方案5】：Java 中的 for-each 循环使用底层的迭代器机制。所以它与以下内容相同：
Iterator<String> iterator = someList.iterator();
while (iterator.hasNext())
String item = iterator.next();
System.out.println(item);
【讨论】：
这是人们在 for-each 之前实际使用的，而不是 C 风格的 for 语句。【参考方案6】：JLS 中定义的 for-each 循环可以有两种形式：
如果 Expression 的类型是 Iterable 的子类型，则翻译为：
List<String> someList = new ArrayList<String>();
someList.add("Apple");
someList.add("Ball");
for (String item : someList)
System.out.println(item);
// IS TRANSLATED TO:
for(Iterator<String> stringIterator = someList.iterator(); stringIterator.hasNext(); )
String item = stringIterator.next();
System.out.println(item);
如果表达式必须具有数组类型T[]，则：
String[] someArray = new String[2];
someArray[0] = "Apple";
someArray[1] = "Ball";
for(String item2 : someArray)
System.out.println(item2);
// IS TRANSLATED TO:
for (int i = 0; i < someArray.length; i++)
String item2 = someArray[i];
System.out.println(item2);
Java 8 引入了流，这些流通常在下降大小的数据集上表现更好。我们可以将它们用作：
someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);
【讨论】：
最相关和最准确的答案。 Enchansed for 确实有两种翻译。 我完全不同意：Java 8 引入了通常性能更好的流。，只有在处理足够大的数据集时，流才是真正可行的。另外.stream().forEach() 可以替换为.forEach()
我没有这么想.forEach()，因为forEeach的运行时间比for循环多，所以forEarch不是最好的解决方案【参考方案7】：
nsayer 的回答暗示了这一点，但值得注意的是，当“someList”是实现 java.lang.Iterable 的 anything 时，OP 的 for(..) 语法将起作用——它不会必须是一个列表，或者来自 java.util 的一些集合。因此，即使您自己的类型也可以使用这种语法。
【讨论】：
fd 是正确的 - 当 for(:) 习惯用法的右侧使用 int 和 array.length 而不是获取 Iterator 时的内部代码。 forums.sun.com/thread.jspa?messageID=2743233【参考方案8】：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";
现在如果我们将 s 转储到控制台，我们会得到：
hello
2 is cool
hello
hello
【讨论】：
【参考方案9】：在 Java 8 中你可以使用这个：
List<String> messages = Arrays.asList("First", "Second", "Third");
void forTest()
messages.forEach(System.out::println);
输出
First
Second
Third
【讨论】：
这个随机信息甚至不能远程回答问题【参考方案10】：Java“for-each”循环结构将允许对两种类型的对象进行迭代：
T[] （任何类型的数组）
java.lang.Iterable<T>
Iterable<T> 接口只有一种方法：Iterator<T> iterator()。这适用于Collection<T> 类型的对象，因为Collection<T> 接口扩展了Iterable<T>。
【讨论】：
【参考方案11】：Wikipedia 中提到的 foreach 循环的概念突出显示如下：
然而，与其他 for 循环结构不同的是，foreach 循环通常 保持没有明确的反击：他们基本上说“这样做是为了 这组中的所有内容”，而不是“这样做 x 次”。这避免了 潜在的逐一错误并使代码更易于阅读。
因此，foreach 循环的概念描述了该循环不使用任何显式计数器，这意味着无需使用索引来遍历列表，从而避免用户出现错误。为了描述这种非一错误的一般概念，让我们举一个使用索引遍历列表的循环示例。
// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++)
但是假设如果列表从索引 1 开始，那么这个循环将抛出一个异常，因为它不会在索引 0 处找到任何元素，并且这个错误被称为非一错误。因此，为了避免这种非同一个错误，使用了 foreach 循环的概念。可能还有其他优点，但我认为这是使用 foreach 循环的主要概念和优点。
【讨论】：
【参考方案12】：在 Java 8 中，他们引入了 forEach。使用 List，可以循环 Maps。
使用 for each 循环一个列表
List<String> someList = new ArrayList<String>();
someList.add("A");
someList.add("B");
someList.add("C");
someList.forEach(listItem -> System.out.println(listItem))
或
someList.forEach(listItem->
System.out.println(listItem);
);
使用 for each 循环地图
Map<String, String> mapList = new HashMap<>();
mapList.put("Key1", "Value1");
mapList.put("Key2", "Value2");
mapList.put("Key3", "Value3");
mapList.forEach((key,value)->System.out.println("Key: " + key + " Value : " + value));
或
mapList.forEach((key,value)->
System.out.println("Key : " + key + " Value : " + value);
);
【讨论】：
【参考方案13】：这是一个等价的表达式。
for(Iterator<String> sit = someList.iterator(); sit.hasNext(); )
System.out.println(sit.next());
【讨论】：
【参考方案14】：for (Iterator<String> itr = someList.iterator(); itr.hasNext(); )
String item = itr.next();
System.out.println(item);
【讨论】：
【参考方案15】：使用包括Java 7 在内的旧Java 版本，您可以使用foreach 循环，如下所示。
List<String> items = new ArrayList<>();
items.add("A");
items.add("B");
items.add("C");
items.add("D");
items.add("E");
for(String item : items)
System.out.println(item);
以下是在Java 8 中使用foreach 循环的最新方法
（使用forEach + lambda 表达式或方法引用循环列表）
//lambda
//Output : A,B,C,D,E
items.forEach(item->System.out.println(item));
//method reference
//Output : A,B,C,D,E
items.forEach(System.out::println);
有关更多信息，请参阅此链接。
https://www.mkyong.com/java8/java-8-foreach-examples/
【讨论】：
【参考方案16】：另请注意，在原始问题中使用“foreach”方法确实有一些限制，例如在迭代期间无法从列表中删除项目。
新的 for 循环更易于阅读，无需单独的迭代器，但仅在只读迭代过程中真正可用。
【讨论】：
在这些情况下，使用removeIf 可能是正确的工具【参考方案17】：
forEach 的替代方案，以避免您的“for each”：
List<String> someList = new ArrayList<String>();
变体 1（普通）：
someList.stream().forEach(listItem ->
System.out.println(listItem);
);
变体 2（并行执行（更快））：
someList.parallelStream().forEach(listItem ->
System.out.println(listItem);
);
【讨论】：
应该提到它是在 Java 1.8 中添加的 我们不能 100% 确定使用的是同一个线程。如果我想确保使用相同的线程，我喜欢使用for( 表单。如果我喜欢允许多线程执行，我喜欢使用流形式。【参考方案18】：
它通过消除所有基本的循环杂乱来为您的代码增添美感。它使您的代码看起来很干净，如下所示。
正常for循环：
void cancelAll(Collection<TimerTask> list)
for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
i.next().cancel();
使用 for-each：
void cancelAll(Collection<TimerTask> list)
for (TimerTask t : list)
t.cancel();
for-each 是对实现 Iterator 的集合的构造。请记住，您的集合应该实现 Iterator；否则你不能将它与 for-each 一起使用。
以下行被读作“for each TimerTask t in list.”
for (TimerTask t : list)
在 for-each 的情况下出错的可能性较小。您不必担心初始化迭代器或初始化循环计数器并终止它（存在错误的地方）。
【讨论】：
【参考方案19】：在 Java 8 之前，您需要使用以下内容：
Iterator<String> iterator = someList.iterator();
while (iterator.hasNext())
String item = iterator.next();
System.out.println(item);
但是，随着 Java 8 中 Streams 的引入，您可以用更少的语法来做同样的事情。例如，对于您的someList，您可以这样做：
someList.stream().forEach(System.out::println);
你可以找到更多关于流here的信息。
【讨论】：
The foreach loop, added in Java 5 (also called the "enhanced for loop"), is equivalent to using a java.util.Iterator【参考方案20】：
它看起来像这样。很邋遢。
for (Iterator<String> i = someList.iterator(); i.hasNext(); )
System.out.println(i.next());
Sun documentation 中有一篇很好的关于 for each 的文章。
【讨论】：
【参考方案21】：正如许多好的答案所说，如果对象想要使用 for-each 循环，则必须实现 Iterable interface。
我将发布一个简单的示例，并尝试以不同的方式解释 for-each 循环的工作原理。
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-each 关键字的使用转换为Iterator 的使用。这可以解释为什么没有实现Iterable interface 的对象在尝试使用for-each 循环时会抛出Exception。
【讨论】：
【参考方案22】：Java for each loop（又名增强的 for 循环）是 for 循环的简化版本。优点是需要编写的代码更少，需要管理的变量也更少。缺点是您无法控制步长值，也无法访问循环体内的循环索引。
当步长为 1 的简单增量并且您只需要访问当前循环元素时，最好使用它们。例如，如果您需要循环遍历数组或 Collection 中的每个元素，而不是查看当前元素的前方或后方。
没有循环初始化，没有布尔条件，步长值是隐式的，是一个简单的增量。这就是为什么它们被认为比常规 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 值存储在 in currentValue 变量中。
输出：
1
3
5
7
9
示例——字符串数组
我们可以使用 for-each 循环遍历字符串数组。循环声明状态：循环 myStrings String 数组并将当前 String 值存储在 in 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 字符串列表并将当前列表值存储在 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
来源：Loops in Java – Ultimate Guide
【讨论】：
【参考方案23】：正如许多其他答案正确指出的那样，foreachloop 只是相同旧 forloop 的语法糖，编译器将其转换为相同的旧 for 循环。
javac（open jdk）有一个开关-XD-printflat，它会生成一个去掉所有语法糖的java文件。完整的命令如下所示
javac -XD-printflat -d src/ MyFile.java
//-d is used to specify the directory for output java file
让我们去掉语法糖
为了回答这个问题，我创建了一个文件并编写了两个版本的for each，一个带有array，另一个带有list。我的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);
当我用上面的开关compiled这个文件时，我得到了以下输出。
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);
您可以看到，每个循环的其他语法糖（自动装箱）都已更改为简单循环。
【讨论】：
【参考方案24】：public static Boolean Add_Tag(int totalsize)
List<String> fullst = new ArrayList<String>();
for(int k=0;k<totalsize;k++)
fullst.addAll();
【讨论】：
【参考方案25】：Java for-each 习惯用法只能应用于 *Iterable 类型的数组或对象。这个习语是隐式，因为它真正由迭代器支持。 Iterator 由程序员编写，通常使用整数索引或节点（取决于数据结构）来跟踪其位置。在纸面上，它比常规的 for 循环慢，至少对于像数组和列表这样的“线性”结构来说是这样，但它提供了更大的抽象。
【讨论】：
-1：这不太可读（通常）：即使您自己的示例（第一个）也是错误的，因为它遗漏了数组中的第一个元素。【参考方案26】：这看起来很疯狂，但它确实有效
List<String> someList = new ArrayList<>(); //has content
someList.forEach(System.out::println);
这行得通。 魔法
【讨论】：
这需要 Java 1.8 + 甚至没有远程回答问题【参考方案27】：我认为这会奏效：
for (Iterator<String> i = someList.iterator(); i.hasNext(); )
String x = i.next();
System.out.println(x);
【讨论】：
请解释为什么您的代码并尝试回答“Java 'for each' 循环如何工作？”的问题【参考方案28】：代码是：
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 For Each loop:");
for (String item : someList)
System.out.println(item);
//Iteration using 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));
【讨论】：
1) 这是不正确的。与可迭代对象（例如列表）上的 for-each 直接等效的方法使用迭代器。 JLS 就是这么说的。查一下。 2）我们不需要这个问题的更多答案。请不要为旧问题添加另一个答案，浪费大家的时间。找出您可以回答的新问题。以上是关于Java 'for each' 循环是如何工作的？的主要内容，如果未能解决你的问题，请参考以下文章
For-Each循环Java错误ArrayIndexOutOfBoundsException
Java，如何在“for each”循环中获取当前索引/键[重复]