Java为每个循环如何工作？

考虑：

List<String> someList = new ArrayList<String>(); // add "monkey", "donkey", "skeleton key" to someList 

 for (String item : someList) { System.out.println(item); } 

没有使用for each语法，等价for循环是什么样的？

Answer 1

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

请注意，如果你需要使用i.remove(); 在你的循环中，或以某种方式访问​​实际的迭代器，你不能使用for ( : ) ：）成语，因为实际的迭代器只是被推断出来的。

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

此外，如果for (:)成语的右侧是一个array而不是一个Iterable对象，则内部代码将使用一个int index计数器，并相对于array.length进行检查。 请参阅Java语言规范 。

Answer 2

对于每个数组也是有效的。 例如

 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]以下是正在发生的更长的forms：

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

请注意，如果你需要使用i.remove（）; 在你的循环中，或以某种方式访问​​实际的迭代器，你不能使用for（：）成语，因为实际的Iterator只是被推断出来的。

[丹尼斯布埃诺]

这是由nsayer的答案，但值得注意的是，（..）语法的OP将工作，当“someList”是任何实现java.lang.Iterable – 它不一定是一个列表，或从集合java.util中。 因此，即使你自己的types，也可以使用这个语法。

Answer 3

这是一个不承担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语法允许这种常见模式以更自然，语法更less的方式书写。

 for(char grade : grades) { // foreach grade in grades System.out.print(grade); // print that grade } 

此外，此语法对于不支持数组索引但实现Java Iterable接口的对象（如List或Sets）有效。

Answer 4

在Java 5中添加的foreach循环 （也称为“增强for循环”）相当于使用java.util.Iterator – 它的语法糖作为同一事物。 因此，在逐个读取每个元素时，应该总是select一个foreach作为迭代器，因为它更加方便和简洁。

的foreach

 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 。 例如，尝试在使用foreach删除一个元素可能会（将会）导致ConcurrentModificationException 。

foreach与：基本的区别

for和foreach之间唯一的实际区别是，在可索引对象的情况下，您无权访问索引。 一个例子，当基本for循环是必需的：

 for(int i = 0; i < array.length; i++) { if(i < 5) { //Do something special } else { //Do other stuff } } 

虽然你可以用foreach手动创build一个单独的索引intvariables

 int idx = -1; for(int i : intArray) { idx++; ... } 

不build议这样做，因为可变范围并不理想，基本for循环只是这种用例的标准和预期格式。

for ：performance

访问集合时， foreach比基本for循环的数组访问要快得多 。 当访问数组时，但是 – 至less在原始数组和封装数组中 – 通过索引访问的速度要快得多。

对基本int数组的迭代器和索引访问进行定时

当访问int或Integer数组时，索引比迭代器快23-40％。 下面是这篇文章底部的testing类的输出，它将100个元素的primitive-int数组中的数字相加（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数组，索引仍然是明显的赢家，但只有百分之十八到百分之二十五快。

对于集合，迭代器比索引更快

但是，对于Integers List ，迭代器是明显的赢家。 只要将testing类中的int数组更改为

 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}); 

并对testing函数（ 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) 

在一个testing中，它们几乎是等价的，但是对于集合，迭代器会获胜。

这篇文章是基于我在stackexchange上写的两个答案：

• https://stackoverflow.com/questions/22110482/uses-and-syntax-for-for-each-loop-in-java/22110517#22110517
• Should I use an Iterator or a forloop to iterate?

一些更多的信息： Which is more efficient, a for-each loop, or an iterator?

完整的testing类

在stackoverflow上阅读这个问题之后，我创build了这个compare-the-time-it-take-do-any-two-things类

  import java.text.NumberFormat; import java.util.Locale; /** &lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt; @see &lt;CODE&gt;&lt;A HREF=&quot;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt; **/ 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 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 } 

Answer 5

java中的for-each循环使用基础的迭代器机制。 所以它与以下内容相同：

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

Answer 6

在Java 8的function，你可以使用这个：

 List<String> messages = Arrays.asList("First", "Second", "Third"); void forTest(){ messages.forEach(System.out::println); } 

产量

 First Second Third 

Answer 7

这是由nsayer的答案，但值得注意的是，（..）语法的OP将工作，当“someList”是任何实现java.lang.Iterable – 它不一定是一个列表，或从集合java.util中。 因此，即使你自己的types，也可以使用这个语法。

Answer 8

Java“for-each”循环结构将允许迭代两种types的对象：

• T[] （任何types的数组）
• java.lang.Iterable<T>

Iterable<T>接口只有一个方法： Iterator<T> iterator() 。 这适用于Collection<T>types的对象，因为Collection<T>接口扩展了Iterable<T> 。

Answer 9

foreach循环语法是：

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

EX：

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

输出：

 Java Coffe Is Cool 

警告：您可以使用foreach循环访问数组元素，但不能初始化它们。 使用原来的循环。
警告：您必须将数组的types与其他对象相匹配。

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

如果你想编辑元素，使用原来的循环像这样：

 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转移到consle，我们就可以得到

 hello 2 is cool hello hello 

Answer 10

维基百科中提到的foreach循环的概念如下所示：

然而，不同于其他的循环结构，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开始，那么这个循环将会抛出一个exception，因为它将在索引0处找不到任何元素，并且这个错误被称为逐个错误。 所以为了避免这个错误，使用了foreach循环的概念。 也可能有其他的优势，但这是我认为是使用foreach循环的主要概念和优势。

Answer 11

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

Answer 12

正如JLS中所定义的 – 每个循环可以有两种forms：

1. 如果expression式的types是Iterable的子types，那么翻译如下：

    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); } 

2. 如果expression式必须有一个数组typesT[]那么：

    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引入了性能更好的stream。 我们可以使用它们作为：

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

Answer 13

这是一个等效的expression式。

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

Answer 14

另外请注意，在原始问题中使用“foreach”方法确实有一些限制，例如在迭代过程中无法从列表中删除项目。

新的for循环更容易阅读，并且不再需要单独的迭代器，但是只能在只读迭代遍中使用。

Answer 15

通过消除所有基本的循环混乱，它为您的代码增添了美感。 它给你的代码提供了一个清晰的外观，certificate如下。

正常循环：

 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的集合的构造。 请记住，你的集合应该实现迭代器 ; 否则你不能用for-each。

以下行读作“ 对于列表中的每个TimerTask t ”。

 for (TimerTask t : list) 

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

Answer 16

它看起来像这样。 非常蹩脚。

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

在Sun文档中有很好的介绍。

Answer 17

每个为了避免你的“每个”替代：

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

瓦里安1（平原）：

 someList.stream().forEach(listItem -> { System.out.println(listItem); }); 

变体2（并行执行（更快））：

 someList.parallelStream().forEach(listItem -> { System.out.println(listItem); }); 

Answer 18

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

我将发布一个简单的例子，并尝试以不同的方式解释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 。

Answer 19

 public static Boolean Add_Tag(int totalsize) { List<String> fullst = new ArrayList<String>(); for(int k=0;k<totalsize;k++) { fullst.addAll(); } } 

Answer 20

Java for-each成语只能应用于* Iterabletypes的数组或对象。 这个成语是隐含的，因为它真正由一个迭代器支持。 迭代器由程序员编程，通常使用整数索引或节点（取决于数据结构）来跟踪其位置。 在纸上它比常规的for循环慢，至less像数组和列表的“线性”结构，但它提供了更大的抽象。