每个'循环的Java'如何工作？

考虑:

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

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

如果for不使用for each语法,等效循环会是什么样的？

1> nsayer..：

---

for (Iterator 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语言规范.

---

我发现只是调用while循环就像*while(someList.hasMoreElements()){//做某事}}* - 让我接近我希望在搜索这个问题时希望找到的编码优雅.

---

另请参阅解释foreach循环的http://docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html(介绍时)

2> Mikezx6r..：

---

每个的构造对数组也有效.例如

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 i = someList.iterator(); i.hasNext(); ) {
  String item = i.next();
  System.out.println(item);
}

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

[丹尼斯布埃诺]

这是由nsayer的回答所暗示的,但值得注意的是,当"someList"是实现java.lang.Iterable的任何东西时,OP的for(..)语法将起作用 - 它不一定是列表,也不一定是来自java.util中.因此,即使您自己的类型也可以使用此语法.

3> aliteralmind..：

---

在Java 5中添加的foreach循环(也称为"增强的for循环")相当于使用--it的语法糖来做同样的事情.因此,当逐个读取每个元素并按顺序时,应始终在迭代器上选择a,因为它更方便和简洁.java.util.Iteratorforeach

的foreach

for(int i : intList) {
   System.out.println("An element in the list: " + i);
}

迭代器

Iterator intItr = intList.iterator();
while(intItr.hasNext()) {
   System.out.println("An element in the list: " + intItr.next());
}

在某些情况下,您必须Iterator直接使用.例如,尝试在使用foreachcan(将？)时删除元素会导致a ConcurrentModificationException.

foreachvs.: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循环只是此用例的标准和预期格式.

foreachvs.:for表现

当访问的集合,一个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 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[]to List,lengthto 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上写的两个答案:

Java中for-each循环的使用和语法

我应该使用Iterator还是forloop进行迭代？

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

完整的测试课程

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

import  java.text.NumberFormat;
import  java.util.Locale;

/**
   <P>{@code java TimeIteratorVsIndexIntArray 1000000}</P>

   @see  <CODE><A HREF="/sf/ask/17360801/">/sf/ask/17360801/</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

}

---

这个答案现在是[博客文章](http://aliteralmind.wordpress.com/2014/03/22/for_foreach/),是根据我写的两个相关答案创建的:[这里](http:// stackoverflow.com/questions/22540025/should-i-use-an-iterator-or-a-forloop-to-iterate/22540191#22540191)和[here](http://stackoverflow.com/questions/22110482/uses -and-语法换的for-each - 环 - 在-java的/ 22110517#22110517).它还包括一个通用的类,用于比较两个函数的速度(在底部).

4> MRocklin..：

---

这是一个不承担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> toluju..：

---

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

Iterator iterator = someList.iterator();

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

6> EfForEffort..：

---

这是由nsayer的回答所暗示的,但值得注意的是,当"someList"是实现java.lang.Iterable的任何东西时,OP的for(..)语法将起作用- 它不一定是列表,也不一定是来自java.util中.因此,即使您自己的类型也可以使用此语法.

7> 小智..：

---

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

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

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

产量

First
Second
Third

---

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

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> i_am_zero..：

---

正如JLS中定义的那样,每个循环可以有两种形式:

如果Expression的类型是子类型,Iterable那么翻译如下:

List someList = new ArrayList();
someList.add("Apple");
someList.add("Ball");
for (String item : someList) {
    System.out.println(item);
}

// IS TRANSLATED TO:

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

如果Expression必须具有数组类型,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确实有两个翻译.

10> Ryan Delucch..：

---

Java"for-each"循环结构将允许迭代两种类型的对象:

T[] (任何类型的数组)

java.lang.Iterable

该Iterable接口只有一个方法:Iterator iterator().这适用于类型的对象,Collection因为Collection接口扩展Iterable.

11> 小智..：

---

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

然而,与其他for循环结构不同,foreach循环通常不维护显式计数器:它们基本上说"对此集合中的所有内容执行此操作",而不是"执行此x次".这避免了潜在的逐个错误,并使代码更易于阅读.

所以foreach循环的概念描述了循环不使用任何显式计数器,这意味着不需要使用索引遍历列表,因此它可以使用户免于一个错误.为了描述这个逐个错误的一般概念,让我们举一个循环的例子来使用索引在列表中遍历.

// In this loop it is assumed that the list starts with index 0
for(int i=0; i

但是假设如果列表以索引1开始,则此循环将抛出异常,因为它将在索引0处找不到任何元素,并且此错误称为逐个错误.因此,为了避免这种逐个错误,使用了foreach循环的概念.可能还有其他优点,但我认为这是使用foreach循环的主要概念和优势.

        

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

        

13> Dulith De Co..：
使用较旧的Java版本,包括Java 7您可以使用foreach循环如下.

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


以下是使用foreach循环的最新方法Java 8

(使用forEach+ lambda表达式或方法引用循环List )

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

        

14> 小智..：
这是一个等价的表达式.

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

        

15> billjamesdev..：
另请注意,在原始问题中使用"foreach"方法确实存在一些限制,例如在迭代期间无法从列表中删除项目.

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

        

16> vivekkurien..：
在Java 8中,他们介绍了forEach.使用它List,可以循环地图.

使用每个循环列表

List someList = new ArrayList();
someList.add("A");
someList.add("B");
someList.add("C");

someList.forEach(listItem -> System.out.println(listItem))


要么 

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


使用每个循环地图

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

        

17> Alexander Dr..：
forEach的替代方案,以避免您的"为每个人":

List someList = new ArrayList();


变式1(普通):

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


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

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

        
应该提到它是在Java 1.8中添加的 

18> Manohar..：
它通过删除所有基本的循环混乱为您的代码增添了美感.它为您的代码提供了一个干净的外观,下面是合理的.

正常for循环:

void cancelAll(Collection list) {
    for (Iterator i = list.iterator(); i.hasNext();)
         i.next().cancel();
}


使用for-each:

void cancelAll(Collection list) {
    for (TimerTask t : list)
        t.cancel();
}


for-each是实现Iterator的集合上的构造.请记住,您的收藏应该实现Iterator ; 否则你不能将它与for-each一起使用.

以下行读作" 列表中的每个TimerTask t ".

for (TimerTask t : list)


在for-each的情况下出错的可能性较小.您不必担心初始化迭代器或初始化循环计数器并终止它(存在错误的范围).

        

19> stackFan..：
在Java 8之前,您需要使用以下内容:

Iterator iterator = someList.iterator();

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


但是,随着Java 8中Streams的引入,你可以用更少的语法做同样的事情.例如,对于您someList可以这样做:

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


你可以找到更多关于流在这里.

        

20> Pete..：
它看起来像这样.非常苛刻.

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


有一个良好的书面记录每个中Sun文档.

        

21> L Joey..：
正如许多好的答案所说,一个对象必须实现Iterable interface它想要使用for-each循环.

我将发布一个简单的示例,并尝试以不同的方式解释for-each循环的工作原理.

该for-each循环示例:

public class ForEachTest {

    public static void main(String[] args) {

        List list = new ArrayList();
        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."":()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会Exception在尝试使用for-each循环时抛出.