题 每个'循环的Java'如何工作?


考虑:

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
    System.out.println(item);
}

会有什么相同的 for 循环看起来没有使用 为每个人 句法?


1203
2017-09-17 16:44


起源




答案:


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

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

正如Denis Bueno所指出的,此代码适用于实现该代码的任何对象 Iterable 接口

另外,如果右边的那个 for (:) 成语是一个 array 而不是一个 Iterable 对象,内部代码使用int索引计数器并检查 array.length 代替。见 Java语言规范


970
2017-09-17 16:46



我发现只是调用while循环 while(someList.hasMoreElements()){//做某事}}  - 当我搜索这个问题时,让我接近我希望找到的编码优雅。 - James T Snell
另见 docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html 解释foreach循环(当它被引入时) - PhoneixS
对于android studio开发人员: import java.util.Iterator; 和 import java.lang.Iterable; - dsdsdsdsd


构造 为每个人 也适用于数组。例如

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(:)成语,因为   实际的迭代器只是   推断。

[丹尼斯布埃诺]

这是由纳赛尔的回答所暗示的,但是   值得注意的是OP的(...)   当“someList”是时,语法将起作用   任何实现的东西   java.lang.Iterable - 它没有   成为一个列表,或来自的一些集合   java.util中。甚至你自己的类型,   因此,可以与此一起使用   句法。


424
2017-09-17 17:06





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


119
2017-10-31 16:35





foreach 循环,补充说 Java 5 (也称为“增强for循环”),相当于使用a java.util.Iterator - 同样的东西的语法糖。因此,在阅读每个元素时,一个接一个地按顺序排列 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 可以(将?)导致a ConcurrentModificationException

foreach 与 for:基本差异

唯一的实际区别 for 和 foreach 就是在可索引对象的情况下,您无权访问索引。基本的例子 for 循环是必需的:

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

虽然您可以手动创建一个单独的索引int-variable foreach

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

不推荐,因为 可变范围 不理想,基本 for 循环只是此用例的标准和预期格式。

foreach 与 for:表现

访问集合时,a foreach 是 明显更快 比基本的 for 循环的数组访问。然而,当访问数组时 - 至少使用原始数据包和包装器数组 - 通过索引进行访问的速度要快得多。

定义原始int数组的迭代器和索引访问之间的差异

指数是23-40 访问时比迭代器快一百分之一 int 要么 Integer 阵列。这是本文底部测试类的输出,它将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%。

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

为一个 List 的 Integers然而,迭代器是明显的赢家。只需将测试类中的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});

并对测试功能进行必要的更改(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上写的两个答案:

更多信息: 哪个更有效,for-each循环或迭代器?

完整的测试课程

我在阅读之后创建了这个比较 - 时间 - 任意两件事的课程 这个问题 在Stack Overflow上:

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

}

114
2018-03-01 12:47



这个答案现在是一个 博客文章 并且是根据我写的两个相关答案创建的: 这里 和 这里。它还包括一个通用的类,用于比较两个函数的速度(在底部)。 - aliteralmind
这里只是一个小评论,你不应该断然说明(:)语法总是更好地访问集合;如果你使用数组列表,for(:)循环将比使用for(int i = 0,len = arrayList.size(); i <len; i ++)慢约2倍。我想你在[link]中提到过( stackoverflow.com/questions/2113216/...)无论如何,但重要的是突出... - Leo
@Leo这是一个好点。 ArrayList是Collection,但是它由一个数组支持,这就是为什么正常情况对它更好。 - aliteralmind
我想象 for(int value : int_array) {/* loop content */} 在你的测试中是最慢的,因为它在语法上是等价的 for(int i = 0; i < int_array.length; i++) {int value = int_array[i]; /* loop content */},这不是你的测试所比较的。 - megaflop
很好的解释!! - Yohan Malshika


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

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

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

34
2017-09-17 16:46





在Java 8功能中,您可以使用:

List<String> messages = Arrays.asList("First", "Second", "Third");

void forTest(){
    messages.forEach(System.out::println);
}

产量

First
Second
Third

21
2018-04-19 15:22



这个随机信息甚至没有远程回答这个问题 - Tim Castelijns


nsayer的回答暗示了这一点,但值得注意的是,当“someList”是“someList”时,OP的for(..)语法将起作用 什么 实现java.lang.Iterable - 它不必是一个列表,也不一定是java.util中的一些集合。因此,即使您自己的类型也可以使用此语法。


19
2017-09-17 16:50



此外,通过一些狡猾的魔术对象阵列也可以工作。 - Mike Tunnicliffe
fd是正确的 - 当for(:) idiom的右侧使用int和array.length而不是获取Iterator时的内部代码。 forums.sun.com/thread.jspa?messageID=2743233 - nsayer