Java'；每个'；循环工作？

考虑：

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

如果不使用for each语法，for的等价

循环会是什么样子？
for（迭代器i=someIterable.Iterator（）；i.hasNext（）；）{
String item=i.next（）；
系统输出打印项次（项）；
}

请注意，如果需要使用
i.remove（）
习惯用法，因为实际的迭代器只是推断出来的

正如Denis Bueno所指出的，此代码适用于实现

此外，如果（：）

习惯用法的

右侧是
数组
而不是
Iterable
对象，则内部代码将使用int索引计数器并检查
数组.length
。请参阅。
for each循环在Java中使用底层迭代器机制。因此，它与以下内容相同：

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

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

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

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

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

Iterator Iterator=someList.Iterator（）；
while（iterator.hasNext（））{
String item=iterator.next（）；
系统输出打印项次（项）；
}
这里有一个等价的表达式

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

for（迭代器sit=someList.Iterator（）；sit.hasNext（）；）{
System.out.println（sit.next（））；
}
它看起来像这样。非常粗糙

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

for（迭代器i=someList.Iterator（）；i.hasNext（）；）
System.out.println（i.next（））；

在.
for（迭代器itr=someList.Iterator（）；itr.hasNext（）；）中，每个都有一个很好的writeup{
String item=itr.next（）；
系统输出打印项次（项）；
}
nsayer的回答暗示了这一点，但值得注意的是，当“someList”是实现java.lang.Iterable的任何东西时，OP的for（..）语法将起作用——它不必是列表，也不必是来自java.util的某个集合。因此，即使您自己的类型也可以与此语法一起使用。
还要注意，在原始问题中使用“foreach”方法确实有一些限制，例如在迭代过程中无法从列表中删除项

新的for循环更易于读取，并且不需要单独的迭代器，但它只在只读迭代过程中才真正可用。
每个循环的构造也对数组有效。e、 g

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

for（int i=0；i

因此，总体总结：

以下是正在发生的事情的较长形式：

for（迭代器i=someList.Iterator（）；i.hasNext（）；）{
String item=i.next（）；
系统输出打印项次（项）；
}

请注意，如果您需要使用
i、 删除（）；在您的循环中，或访问
实际的迭代器在某种程度上
无法使用for（：）习惯用法，因为
实际的迭代器只是
推断


nsayer的回答暗示了这一点，但是
值得注意的是，OP是针对（…）
当使用“someList”时，语法将起作用
任何实现
java.lang.Iterable——它没有
成为一个列表，或者是来自
java.util。即使是你自己的类型，
因此，可以与此一起使用
语法

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


T[]
（任何类型的数组）
java.lang.Iterable

Iterable
接口只有一个方法：
Iterator Iterator（）
。这适用于
Collection
类型的对象，因为
Collection
接口扩展了
Iterable
以下是一个答案，它不假设Java迭代器的知识。它不太精确，但对教育很有用

编程时，我们通常编写如下代码：

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

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

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

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

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

此外，此语法对不支持数组索引但实现Java Iterable接口的列表或集合等对象有效。
维基百科中提到的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++){

}

//在此循环中，假定列表以索引0开头
对于（inti=0；i，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

1
3
5
7
9

alpha
beta
gamma
delta

alpha
beta
gamma
delta

alpha
delta
beta
gamma

警告：您可以使用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";
}

添加在（也称为“增强for循环”）中的，相当于对同一事物使用一个——它的语法糖。因此，当逐个并按顺序读取每个元素时，应始终在迭代器上选择一个
foreach
，因为它更方便和简洁

弗雷奇
迭代器
尽管可以使用
foreach
手动创建单独的索引int变量

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

不建议这样做，因为这样做并不理想，而
循环的基本
只是此用例的标准和预期格式

foreach
与
for
：性能
在访问集合时，
foreach
比
循环的数组访问的基本
更重要。但是，在访问数组时，至少对于基本数组和包装数组而言，通过索引进行访问是非常重要的
int idx = -1;
for(int i : intArray) {
   idx++;
   ...
}

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

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

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

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

}

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

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

First
Second
Third

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

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

for (TimerTask t : list)

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

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

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

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

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

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;

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

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

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

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

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

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

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

int [] intArray = {1, 3, 5, 7, 9};
for(int currentValue : intArray) {
  System.out.println(currentValue);
}

1
3
5
7
9

String [] myStrings  = {
  "alpha",
  "beta",
  "gamma",
  "delta"
};

for(String currentString : myStrings) {
  System.out.println(currentString);
}

alpha
beta
gamma
delta

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

alpha
beta
gamma
delta

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

alpha
delta
beta
gamma

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

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

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

javac -XD-printflat -d src/ MyFile.java

//-d is used to specify the directory for output java file

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

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

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

import java.util.ArrayList;
import java.util.List;

public class ForLoopDemo {

  public static void main(String[] args) {
    
    List<String> someList = new ArrayList<String>();
    
    someList.add("monkey");
    someList.add("donkey");
    someList.add("skeleton key");
    
    //Iteration using For Each loop
    System.out.println("Iteration using For Each loop:");
    for (String item : someList) {
      System.out.println(item);
    }
    
    //Iteration using normal For loop
    System.out.println("\nIteration using normal For loop:");
    for (int index = 0; index < someList.size(); index++) {
      System.out.println(someList.get(index));
    }
  }
}