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循环是什么样的?

 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语言规范 。

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

 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,也可以使用这个语法。

这是一个不承担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)有效。

在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与:基本的区别

forforeach之间唯一的实际区别是,在可索引对象的情况下,您无权访问索引。 一个例子,当基本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数组的迭代器和索引访问进行定时

当访问intInteger数组时,索引比迭代器快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>lengthsize()等进行必要的修改)

 [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 } 

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

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

在Java 8的function,你可以使用这个:

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

产量

 First Second Third 

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

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

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

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

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 

维基百科中提到的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循环的主要概念和优势。

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

正如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); 

这是一个等效的expression式。

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

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

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

通过消除所有基本的循环混乱,它为您的代码增添了美感。 它给你的代码提供了一个清晰的外观,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) 

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

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

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

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

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

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

瓦里安1(平原):

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

变体2(并行执行(更快)):

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

正如许多好的答案所说,一个对象必须实现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

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

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