Java 'สำหรับแต่ละ' ทำงานอย่างไร

พิจารณา:

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

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

forลูปที่เทียบเท่าจะมีลักษณะอย่างไรโดยไม่ใช้สำหรับแต่ละไวยากรณ์

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

โครงสร้างสำหรับแต่ละยังใช้ได้สำหรับอาร์เรย์ เช่น

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(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 แม้แต่ประเภทของคุณเองก็สามารถใช้กับไวยากรณ์นี้ได้

การforeachวนซ้ำที่เพิ่มในJava 5 (เรียกอีกอย่างว่า "การปรับปรุงสำหรับการวนซ้ำ") เทียบเท่ากับการใช้java.util.Iterator- syntactic น้ำตาลสำหรับสิ่งเดียวกัน ดังนั้นเมื่ออ่านแต่ละองค์ประกอบทีละตัวและเรียงตามลำดับforeachควรเลือกเสมอโดยใช้ตัววนซ้ำเนื่องจากสะดวกและกระชับยิ่งขึ้น

แต่ละ

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

iterator

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

มีสถานการณ์ที่คุณต้องใช้Iteratorโดยตรง ตัวอย่างเช่นการพยายามลบองค์ประกอบในขณะที่ใช้foreachผลลัพธ์ can (will?) จะทำให้ aConcurrentModificationExceptionผลใน

foreach เมื่อเทียบกับ for : ความแตกต่างพื้นฐาน

ข้อแตกต่างเชิงปฏิบัติเพียงอย่างเดียวระหว่าง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ห่วงพื้นฐานเป็นเพียงรูปแบบมาตรฐานและรูปแบบที่คาดไว้สำหรับกรณีการใช้งานนี้

foreachvs. for: ประสิทธิภาพ

เมื่อเข้าถึงคอลเลกชัน a foreachจะเร็วกว่าการforเข้าถึงอาร์เรย์ของ loop พื้นฐานอย่างมาก เมื่อเข้าถึงอาเรย์อย่างไรก็ตามอย่างน้อยก็ด้วยแบบดั้งเดิมและอาเรย์ตัวหุ้ม - การเข้าถึงผ่านทางดัชนีนั้นเร็วกว่ามาก

กำหนดเวลาความแตกต่างระหว่างการวนซ้ำและการเข้าถึงดัชนีสำหรับอินเทอเรนซ์ดั้งเดิม

ดัชนี 23- 40เปอร์เซ็นต์เร็วกว่า iterators เมื่อมีการเข้าถึง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แต่ iterators เป็นผู้ชนะที่ชัดเจน เพียงเปลี่ยน int-array ในคลาสทดสอบเป็น:

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:

• ใช้และไวยากรณ์สำหรับแต่ละลูปใน Java

• ฉันควรใช้ Iterator หรือ forloop เพื่อย้ำ?

ข้อมูลเพิ่มเติมบางอย่าง: อันไหนมีประสิทธิภาพมากกว่าสำหรับแต่ละลูปหรือตัววนซ้ำ

ชั้นทดสอบเต็มรูปแบบ

ฉันสร้างคลาสการเปรียบเทียบแบบเวลาใช้สิ่งที่ต้องทำสองสิ่งหลังจากอ่านคำถามนี้ใน Stack Overflow:

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

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

   @see  <CODE><A HREF="/programming/180158/how-do-i-time-a-methods-execution-in-java">/programming/180158/how-do-i-time-a-methods-execution-in-java</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

}

นี่คือคำตอบที่ไม่ถือว่ามีความรู้เกี่ยวกับ Java Iterators มันแม่นยำน้อยกว่า แต่ก็มีประโยชน์สำหรับการศึกษา

ในขณะที่เขียนโปรแกรมเรามักจะเขียนโค้ดที่มีลักษณะดังนี้:

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

for-each loop ใน Java ใช้กลไกตัววนซ้ำพื้นฐาน ดังนั้นมันจึงเหมือนกับสิ่งต่อไปนี้:

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

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

ในคุณสมบัติของ Java 8 คุณสามารถใช้สิ่งนี้:

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 แม้แต่ประเภทของคุณเองก็สามารถใช้กับไวยากรณ์นี้ได้

ตามที่กำหนดไว้ในJLSสำหรับแต่ละวงสามารถมีสองรูปแบบ:

1. หากประเภทของ Expression เป็นประเภทย่อยของการ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. ถ้า 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);

ไวยากรณ์วนลูป 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

โครงสร้างลูป Java "for-each" จะอนุญาตให้วนซ้ำของวัตถุสองชนิด:

• T[] (อาร์เรย์ทุกประเภท)
• java.lang.Iterable<T>

อินเตอร์เฟซที่มีเพียงหนึ่งวิธีการ:Iterable<T> Iterator<T> iterator()ใช้งานได้กับวัตถุประเภทCollection<T>เพราะCollection<T>Iterable<T>อินเตอร์เฟซที่ยื่นออกมา

แนวคิดของ foreach loop ดังที่ได้กล่าวไว้ใน Wikipedia นั้นมีการเน้นไว้ด้านล่าง:

ซึ่งแตกต่างจากอื่น ๆ สำหรับการสร้างวงอย่างไรก็ตามห่วง foreach มักจะไม่มีการตอบโต้ชัดเจน : พวกเขาบอกว่า "ทำสิ่งนี้กับทุกสิ่งในชุดนี้" แทนที่จะทำ x ครั้งนี้ วิธีนี้จะช่วยหลีกเลี่ยงข้อผิดพลาดที่อาจเกิดขึ้นแบบฉับพลันและทำให้โค้ดอ่านง่ายขึ้น

ดังนั้นแนวคิดของ foreach loop อธิบายว่า loop ไม่ได้ใช้ตัวนับที่ชัดเจนซึ่งหมายความว่าไม่จำเป็นต้องใช้ดรรชนีเพื่อสำรวจในรายการดังนั้นจึงช่วยให้ผู้ใช้ไม่ต้องพลาดข้อผิดพลาด เพื่ออธิบายแนวคิดทั่วไปของข้อผิดพลาดแบบออฟไลน์นี้ให้เรานำตัวอย่างของการวนซ้ำเพื่อสำรวจในรายการโดยใช้ดัชนี

// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++){

}

แต่สมมติว่าถ้ารายการเริ่มต้นด้วยดัชนี 1 ดังนั้นลูปนี้จะส่งข้อยกเว้นเนื่องจากจะไม่พบองค์ประกอบใด ๆ ที่ดัชนี 0 และข้อผิดพลาดนี้เรียกว่าข้อผิดพลาดแบบหนึ่งต่อหนึ่ง ดังนั้นเพื่อหลีกเลี่ยงข้อผิดพลาดแบบ off-by-one นี้จึงใช้แนวคิดของ foreach loop อาจมีข้อดีอื่น ๆ เช่นกัน แต่นี่คือสิ่งที่ฉันคิดว่าเป็นแนวคิดหลักและข้อดีของการใช้ foreach loop

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

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

การใช้ 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/

นี่คือการแสดงออกที่เทียบเท่า

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

นอกจากนี้โปรดทราบว่าการใช้วิธี "foreach" ในคำถามเดิมมีข้อ จำกัด บางประการเช่นไม่สามารถลบรายการออกจากรายการในระหว่างการทำซ้ำ

for-loop ใหม่นั้นง่ายต่อการอ่านและลบความต้องการตัววนซ้ำที่แยกจากกัน แต่สามารถใช้งานได้จริงในการวนซ้ำแบบอ่านอย่างเดียวเท่านั้น

ทางเลือกอื่นสำหรับ foreach เพื่อหลีกเลี่ยง "สำหรับแต่ละ":

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

ชุดที่ 1 (ธรรมดา):

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

ตัวแปร 2 (การประมวลผลแบบขนาน (เร็วกว่า)):

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

มันเพิ่มความสวยงามให้กับรหัสของคุณโดยการลบความยุ่งเหยิงพื้นฐานทั้งหมด มันช่วยให้โค้ดของคุณดูสะอาดตา

forวงปกติ:

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

สำหรับแต่ละคือสร้างกว่าคอลเลกชันที่ดำเนินIterator โปรดจำไว้ว่าคอลเลกชันของคุณควรใช้Iterator ; ไม่เช่นนั้นคุณจะไม่สามารถใช้กับแต่ละรายการได้

บรรทัดต่อไปนี้ถูกอ่านเป็น " สำหรับแต่ละ TimerTask t ในรายการ "

for (TimerTask t : list)

มีโอกาสน้อยกว่าสำหรับข้อผิดพลาดในแต่ละกรณี คุณไม่ต้องกังวลกับการเริ่มต้นตัววนซ้ำหรือการเริ่มต้นตัวนับลูปและยกเลิกมัน (ในกรณีที่มีขอบเขตสำหรับข้อผิดพลาด)

ก่อนหน้า Java 8 คุณต้องใช้สิ่งต่อไปนี้:

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

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

อย่างไรก็ตามด้วยการเปิดตัว Streams ใน Java 8 คุณสามารถทำสิ่งเดียวกันในไวยากรณ์น้อยกว่ามาก ตัวอย่างเช่นสำหรับคุณsomeListคุณสามารถทำ:

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

คุณสามารถค้นหาข้อมูลเพิ่มเติมเกี่ยวกับลำธารที่นี่

มันจะมีลักษณะเช่นนี้ crufty มาก

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

มีเขียนขึ้นที่ดีในการเป็นสำหรับแต่ละในเอกสารอาทิตย์

ดังคำตอบที่ดีมากมายที่กล่าวว่าวัตถุต้องนำไปใช้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จะโยนExceptionเมื่อมันพยายามที่จะใช้for-eachวง

Java สำหรับแต่ละวง (aka ที่เพิ่มขึ้นสำหรับวง) เป็นรุ่นที่เรียบง่ายของการวน ข้อดีคือมีโค้ดน้อยกว่าในการเขียนและตัวแปรในการจัดการน้อยลง ข้อเสียคือคุณไม่สามารถควบคุมค่าขั้นตอนและไม่สามารถเข้าถึงดัชนีลูปภายในตัวลูป

พวกเขาจะใช้ดีที่สุดเมื่อค่าขั้นตอนคือการเพิ่มขึ้นอย่างง่ายของ 1 และเมื่อคุณต้องการเข้าถึงองค์ประกอบห่วงปัจจุบัน ตัวอย่างเช่นหากคุณต้องการวนซ้ำทุกองค์ประกอบในอาร์เรย์หรือคอลเล็กชันโดยไม่ต้องมองไปข้างหน้าหรือข้างหลังองค์ประกอบปัจจุบัน

ไม่มีการกำหนดค่าเริ่มต้นวนซ้ำไม่มีเงื่อนไขบูลีนและค่าขั้นตอนเป็นนัยและเป็นการเพิ่มขึ้นอย่างง่าย นี่คือเหตุผลที่พวกเขาคิดว่าง่ายกว่าปกติสำหรับลูป

ปรับปรุงสำหรับลูปให้ปฏิบัติตามคำสั่งนี้:

1) ร่างกายห่วง

2) ทำซ้ำจากขั้นตอนที่ 1 จนกว่าอาร์เรย์หรือชุดรวมทั้งหมดจะถูกสำรวจ

ตัวอย่าง - อาร์เรย์จำนวนเต็ม

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

ตัวแปร currentValue เก็บค่าปัจจุบันที่วนลูปในอาร์เรย์ intArray สังเกตเห็นว่าไม่มีค่าขั้นตอนชัดเจน - มันเพิ่มขึ้นทีละ 1 เสมอ

เครื่องหมายจุดคู่สามารถถูกหมายถึง“ ใน” ดังนั้นการปรับปรุงสำหรับสถานะการประกาศลูป: วนรอบ intArray และเก็บค่าอาร์เรย์ int ปัจจุบันในตัวแปร currentValue

เอาท์พุท:

1
3
5
7
9

ตัวอย่าง - อาเรย์สตริง

เราสามารถใช้ for-each loop เพื่อวนซ้ำสตริงต่างๆ สถานะการประกาศลูป: วนรอบ myStrings String อาร์เรย์และเก็บค่าสตริงปัจจุบันในตัวแปร currentString

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

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

เอาท์พุท:

alpha
beta
gamma
delta

ตัวอย่าง - รายการ

Enhanced for loop ยังสามารถใช้เพื่อวนซ้ำ 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 List of Strings และเก็บค่า List ปัจจุบันในตัวแปร currentItem

เอาท์พุท:

alpha
beta
gamma
delta

ตัวอย่าง - ตั้งค่า

Enhanced for loop ยังสามารถใช้เพื่อวนซ้ำ 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);
}

สถานะการประกาศวนรอบ: วนชุด my Strings ของสตริงและเก็บค่า Set ปัจจุบันในตัวแปร currentItem โปรดสังเกตว่าเนื่องจากนี่คือชุดค่าสตริงที่ซ้ำกันจะไม่ถูกเก็บไว้

เอาท์พุท:

alpha
delta
beta
gamma

ที่มา: ลูปใน Java - Ultimate Guide

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

ชวาสำหรับแต่ละสำนวนเท่านั้นที่สามารถนำไปใช้กับอาร์เรย์หรือวัตถุชนิด* Iterable สำนวนนี้เป็นนัยตามที่ได้รับการสนับสนุนอย่างแท้จริงโดย Iterator Iterator ถูกโปรแกรมโดยโปรแกรมเมอร์และมักจะใช้ดัชนีจำนวนเต็มหรือโหนด (ขึ้นอยู่กับโครงสร้างข้อมูล) เพื่อติดตามตำแหน่งของมัน บนกระดาษมันช้ากว่าแบบ for-loop ปกติอย่างน้อยสำหรับโครงสร้าง "เชิงเส้น" เช่นอาร์เรย์และรายการ แต่มันให้สิ่งที่เป็นนามธรรมมากขึ้น

มันดูบ้า แต่มันก็ใช้งานได้ดี

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

วิธีนี้ใช้ได้ผล มายากล

ในฐานะที่เป็นคำตอบอื่น ๆ อย่างถูกต้องรัฐfor each loopเป็นเพียงน้ำตาล syntactic มากกว่าเดิมที่เหมือนกันfor loopและเรียบเรียงแปลมันเป็นเรื่องเก่าสำหรับวง

javac (open jdk) มีสวิตช์-XD-printflatซึ่งสร้างไฟล์ java โดยลบน้ำตาล syntactic ทั้งหมด คำสั่งที่สมบูรณ์มีลักษณะเช่นนี้

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

คุณจะเห็นว่าพร้อมกับน้ำตาล syntactic อื่น ๆ (Autoboxing) สำหรับแต่ละลูปได้เปลี่ยนเป็นลูปง่าย ๆ

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

วนซ้ำวัตถุทั้งหมดในตารางรายการ