Java的“ for each”循环如何工作?


1498

考虑:

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

如果for为每种语法使用,等效循环将是什么样?


Answers:


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


14
我发现只是像while(someList.hasMoreElements()){//做某事}}一样调用while循环-使我接近在搜索此问题时希望找到的编码宽限期。
詹姆斯·斯内尔

6
另请参阅docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html,其中介绍了foreach循环(引入时)
PhoneixS 2014年

1
适用于android studio开发人员:import java.util.Iterator;import java.lang.Iterable;
dsdsdsdsd,2016年

令人沮丧的是,java.util.Iterator它没有实现,Iterable因此您无法实现for(String s : (Iterator<String>)foo)。我明白这是为什么,但它刺激性。
Christopher Schultz

499

该构建体的每个也是有效的阵列。例如

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

[丹尼斯·布埃诺]

nsayer的答案暗示了这一点,但值得注意的是,当“ someList”是实现java.lang.Iterable的任何内容时,OP的for(..)语法将起作用。 java.util。因此,即使您自己的类型也可以与此语法一起使用。


161

Java 5中添加的foreach循环(也称为“增强循环”)等效于在同一件事上使用--it的语法糖。因此,在逐个阅读每个元素时,java.util.Iteratorforeach应始终选择a而不是迭代器,因为它更加方便和简洁。

前言

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直接使用。例如,尝试在使用foreachcan(会吗?)的同时删除元素会导致ConcurrentModificationException

foreachfor:基本差异

for和之间的唯一实际区别foreach是,对于可索引对象,您无权访问索引。for需要基本循环的示例:

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

尽管您可以使用手动创建一个独立的int变量索引foreach

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

不建议这样做,因为可变范围不是理想的选择,并且基本for循环只是该用例的标准格式和预期格式。

foreachfor:效果

访问集合时,a foreach速度明显快于基本for循环的数组访问。但是,当访问数组时(至少使用原始数组和包装器数组),通过索引进行访问的速度大大提高。

计时原始整数数组的迭代器和索引访问之间的区别

当访问或数组时,索引比迭代器快23 %到40%。这是这篇文章底部测试类的输出,该输出求和一个100元素的primary-int数组中的数字(A是迭代器,B是索引):intInteger

[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%。

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

对于ListIntegers,但是,迭代器是明显的赢家。只需将测试类中的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>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)

在一次测试中,它们几乎相等,但是通过集合,迭代器获胜。

*这篇文章基于我在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;/programming/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;/programming/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

}

4
这个答案现在是一篇博客文章,是根据我写的两个相关答案创建的:herehere。它还包括一个用于比较两个函数速度的通用类(在底部)。
aliteralmind 2014年

1
此处仅需提一小段评论,您不应明确指出for(:)语法总是对访问集合更好。如果您使用的是数组列表,则for(:)循环将比使用for(int i = 0,len = arrayList.size(); i <len; i ++)慢大约2倍。我认为您在[link](stackoverflow.com/questions/2113216/…)链接中提到了这一点,但重要的是要强调这一点……
Leo

@Leo这是一个好点。ArrayList是Collection,但是它有数组支持,这就是为什么for更好的原因。
aliteralmind 2014年

我想for(int value : int_array) {/* loop content */}您的测试中速度最慢,因为它在语法上等效于for(int i = 0; i < int_array.length; i++) {int value = int_array[i]; /* loop content */},这与您的测试无法比拟。
daiscog

(顺便说一句,我并不是说您的测试是无效的,但可能值得注意的是造成这种差异的原因,以便人们可以根据自己的特定情况选择正确的方法。如果他们int value = int_array[i];在开始测试时循环,那么他们最好也使用foreach。除非出于某种原因,他们也不需要访问索引。总之,这完全取决于上下文。)
daiscog 2015年

129

这是一个不假定具备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接口的对象(如列表或集合)有效。


40

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

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

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

25

在Java 8功能中,可以使用以下命令:

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

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

输出量

First
Second
Third

7
这些随机信息甚至无法远程回答问题
Tim

25

nsayer的答案暗示了这一点,但值得注意的是,当“ someList”是实现java.lang.Iterable的任何东西时,OP的for(..)语法将起作用。 java.util。因此,即使您自己的类型也可以与此语法一起使用。


1
fd是正确的-for(:)惯用法的右侧使用int和array.length而不是获取Iterator时的内部代码。forums.sun.com/thread.jspa?messageID=2743233
nsayer

24

正如JLS中定义的for-each循环可以有两种形式:

  1. 如果表达式的类型是的子类型,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);
    }
  2. 如果表达式必须具有数组类型,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);

2
最相关,最准确的答案。着迷的确实有两种翻译。
Zarial

23

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

21

Java“ for-each”循环构造将允许在两种类型的对象上进行迭代:

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

Iterable<T>接口只有一种方法:Iterator<T> iterator()Collection<T>由于Collection<T>接口扩展,因此这对类型的对象有效Iterable<T>


16

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循环的主要概念和优点。


13

在Java 8中,他们引入了forEach。使用列表,可以循环映射。

循环使用清单

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

循环使用每个地图

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


11

使用较旧的Java版本,包括Java 7您可以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);
        }

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

(使用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/


10

这是一个等效的表达式。

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

10

还要注意,在原始问题中使用“ foreach”方法确实存在一些局限性,例如在迭代过程中无法从列表中删除项目。

新的for循环更易于阅读,并且不需要单独的迭代器,但仅在只读迭代过程中才真正可用。


1
在这些情况下,使用removeIf
nbhd

9

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

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

我们不能100%确保使用相同的线程。for(如果要确保使用相同的线程,我喜欢使用表单。如果我想允许多线程执行,我喜欢使用流形式。
Grim

8

通过消除所有基本的循环混乱,它为代码增加了美感。它将使您的代码看上去更加简洁,下面有理由说明。

正常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一起使用。

下一行读为“ 对于列表中的每个TimerTask t。

for (TimerTask t : list)

如果是for-each,则出错的机会会更少。您不必担心初始化迭代器或初始化循环计数器并终止它(存在错误的地方)。


8

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

您可以在此处找到有关流的更多信息。


The foreach loop, added in Java 5 (also called the "enhanced for loop"), is equivalent to using a java.util.Iterator
Alex78191 '19

7

看起来像这样。很cru

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

Sun文档中都有关于每个方面的出色文章


6

正如许多好的答案所说,如果对象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会抛出一个。Exceptionfor-each


6

每个循环Java(又名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为增量。

可以认为冒号是指“中”。因此,增强的for循环声明状态:遍历intArray并将当前数组int值存储 currentValue变量中。

输出:

1
3
5
7
9

示例–字符串数组

我们可以使用for-each循环遍历字符串数组。循环声明指出:循环myStrings String数组并将当前String值存储 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 of Strings并将当前List值存储 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

资料来源:Java中的循环–终极指南



3

Java foreach习语只能应用于* Iterable类型的数组或对象。这个惯用法是隐式的,因为它确实由Iterator支持。迭代器由程序员编程,并且经常使用整数索引或节点(取决于数据结构)来跟踪其位置。在纸上,它比常规的for循环慢,对于数组和List之类的“线性”结构,至少要慢,但它提供了更大的抽象性。


-1:这(通常)的可读性较差:即使您自己的示例(第一个示例)也是错误的,因为它忽略了数组中的第一个元素。
Ondrej Skopek '16

2

这看起来很疯狂,但嘿,它有效

List<String> someList = new ArrayList<>(); //has content
someList.forEach(System.out::println);

这可行。魔法


1
这需要Java 1.8 +
BARNI

2
甚至没有远程回答问题
Tim

2

正如许多其他答案正确指出的那样,for each loop只是在相同旧代码上的语法糖for loop,编译器将其转换为相同旧版本的for循环。

javac(open jdk)有一个switch -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);
            }
        }
    }
}

您可以看到,每个循环的其他语法糖(自动装箱)已更改为简单循环。


-2
List<Item> Items = obj.getItems();
for(Item item:Items)
             {
                System.out.println(item); 
             }

遍历Items表中的所有对象。


1
用户尚未要求语法
pradipgarala '18
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.