it-swarm-id.com

Bagaimana cara kerja loop 'untuk setiap' Java?

Mempertimbangkan:

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

Seperti apakah loop for yang setara tanpa menggunakan sintaks untuk masing-masing ?

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

Perhatikan bahwa jika Anda perlu menggunakan i.remove(); dalam loop Anda, atau mengakses iterator yang sebenarnya dalam beberapa cara, Anda tidak dapat menggunakan idiom for ( : ), karena iterator yang sebenarnya hanya disimpulkan.

Seperti yang dicatat oleh Denis Bueno, kode ini berfungsi untuk objek apa pun yang mengimplementasikan antarmuka Iterable .

Juga, jika sisi kanan idiom for (:) adalah array daripada objek Iterable, kode internal menggunakan penghitung indeks int dan sebaliknya memeriksa array.length sebagai gantinya. Lihat Spesifikasi Bahasa Jawa .

1090
nsayer

Konstruk untuk masing-masing juga valid untuk array. misalnya.

String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };

for (String fruit : fruits) {
    // fruit is an element of the `fruits` array.
}

yang pada dasarnya setara dengan

for (int i = 0; i < fruits.length; i++) {
    String fruit = fruits[i];
    // fruit is an element of the `fruits` array.
}

Jadi, ringkasan keseluruhan:
[nsayer] Berikut ini adalah bentuk yang lebih panjang dari apa yang terjadi:

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

Perhatikan bahwa jika Anda perlu menggunakan i.remove (); di loop Anda, atau mengakses iterator aktual dengan cara tertentu, Anda tidak dapat menggunakan idiom for (:), karena Iterator yang sebenarnya hanya disimpulkan.

[Denis Bueno]

Ini tersirat oleh jawaban nsayer, tetapi perlu dicatat bahwa sintaks OP untuk (..) akan bekerja ketika "someList" adalah apa pun yang mengimplementasikan Java.lang. Dapat diubah - tidak harus berupa daftar, atau koleksi dari Java.util. Bahkan tipe Anda sendiri, oleh karena itu, dapat digunakan dengan sintaks ini.

464
Mikezx6r

The foreach loop , ditambahkan di Java 5 (juga disebut "enhanced for loop"), setara dengan menggunakan Java.util.Iterator - itu sintaksis gula untuk hal yang sama. Karena itu, ketika membaca setiap elemen, satu per satu dan secara berurutan, foreach harus selalu dipilih daripada iterator, karena lebih nyaman dan ringkas.

untuk setiap

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

Ada beberapa situasi di mana Anda harus menggunakan Iterator secara langsung. Misalnya, berusaha menghapus elemen saat menggunakan foreach can (will?) Menghasilkan ConcurrentModificationException.

foreach vs. for: Perbedaan dasar

Satu-satunya perbedaan praktis antara for dan foreach adalah bahwa, dalam kasus objek yang dapat diindeks, Anda tidak memiliki akses ke indeks. Contoh ketika loop for dasar diperlukan:

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

Meskipun Anda bisa secara manual membuat indeks variabel terpisah dengan foreach,

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

tidak direkomendasikan, karena variabel-lingkup tidak ideal, dan loop for dasar hanyalah format standar dan yang diharapkan untuk kasus penggunaan ini.

foreach vs. for: Kinerja

Saat mengakses koleksi, foreach adalah secara signifikan lebih cepat daripada akses larik for dasar. Ketika mengakses array, namun - setidaknya dengan array primitif dan wrapper - akses melalui indeks secara dramatis lebih cepat.

Mengatur waktu perbedaan antara akses iterator dan indeks untuk array int-primitif

Indeks 23 - 40 persen lebih cepat daripada iterator ketika mengakses array int atau Integer. Berikut ini adalah output dari kelas pengujian di bagian bawah posting ini, yang merangkum angka-angka dalam array elemen-primitif 100-elemen (A adalah iterator, B adalah indeks):

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

Saya juga menjalankan ini untuk array Integer, dan indeks masih merupakan pemenang yang jelas, tetapi hanya antara 18 dan 25 persen lebih cepat.

Untuk koleksi, iterator lebih cepat dari indeks

Namun untuk List dari Integers, iterator adalah pemenang yang jelas. Cukup ganti int-array di kelas uji ke:

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

Dan buat perubahan yang diperlukan pada fungsi-tes (int[] menjadi List<Integer>, length ke size(), dll.):

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

Dalam satu tes mereka hampir setara, tetapi dengan koleksi, iterator menang.

* Posting ini didasarkan pada dua jawaban yang saya tulis di Stack Overflow:

Beberapa informasi lebih lanjut:Mana yang lebih efisien, untuk-setiap loop, atau iterator?

Kelas pengujian lengkap

Saya membuat kelas perbandingan-waktu-dibutuhkan-untuk-melakukan-dua-hal ini setelah membaca pertanyaan ini di 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

}
141
aliteralmind

Berikut ini adalah jawaban yang tidak mengasumsikan pengetahuan tentang Java Iterators. Ini kurang tepat, tetapi berguna untuk pendidikan.

Saat pemrograman kita sering menulis kode yang terlihat seperti berikut:

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

Sintaks foreach memungkinkan pola umum ini ditulis dengan cara yang lebih alami dan tidak terlalu berisik.

for(char grade : grades) {   // foreach grade in grades
    System.out.print(grade); // print that grade
}

Selain itu sintaks ini berlaku untuk objek seperti Daftar atau Set yang tidak mendukung pengindeksan array, tetapi yang mengimplementasikan antarmuka Java Iterable.

125
MRocklin

Untuk-setiap loop di Jawa menggunakan mekanisme iterator yang mendasarinya. Jadi identik dengan yang berikut:

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

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

Dalam fitur Java 8 Anda dapat menggunakan ini:

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

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

Keluaran

First
Second
Third
23
Jrovalle

Ini tersirat oleh jawaban nsayer, tetapi perlu dicatat bahwa sintaks OP untuk (..) akan bekerja ketika "someList" adalah apa saja yang mengimplementasikan Java.lang.Iterable - tidak harus berupa daftar, atau koleksi dari Java.util. Bahkan tipe Anda sendiri, oleh karena itu, dapat digunakan dengan sintaks ini.

22
EfForEffort

Sintaks loop foreach adalah:

for (type obj:array) {...}

Contoh:

String[] s = {"Java", "Coffe", "Is", "Cool"};
for (String str:s /*s is the array*/) {
    System.out.println(str);
}

Keluaran:

Java
Coffe
Is
Cool

PERINGATAN: Anda dapat mengakses elemen array dengan loop foreach, tetapi Anda TIDAK dapat menginisialisasi mereka. Gunakan loop for asli untuk itu.

PERINGATAN: Anda harus mencocokkan jenis array dengan objek lain.

for (double b:s) // Invalid-double is not String

Jika Anda ingin mengedit elemen, gunakan loop for asli seperti ini:

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

Sekarang jika kita membuang s ke konsol, kita mendapatkan:

hello
2 is cool
hello
hello
21
PrivateName

Konstruk loop Java "untuk-masing-masing" akan memungkinkan iterasi atas dua jenis objek:

  • T[] (array jenis apa pun)
  • Java.lang.Iterable<T>

Antarmuka Iterable<T> hanya memiliki satu metode: Iterator<T> iterator(). Ini berfungsi pada objek tipe Collection<T> karena antarmuka Collection<T> meluas Iterable<T>.

20
Ryan Delucchi

Sebagaimana didefinisikan dalam JLS untuk-setiap loop dapat memiliki dua bentuk:

  1. Jika jenis Ekspresi adalah subtipe dari Iterable maka terjemahannya adalah:

    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. Jika Ekspresi tentu memiliki tipe array T[] maka:

    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 telah memperkenalkan stream yang berkinerja lebih baik secara umum. Kita dapat menggunakannya sebagai:

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

Konsep loop foreach seperti yang disebutkan dalam Wikipedia disorot di bawah ini:

Tidak seperti lainnya untuk konstruksi loop, bagaimanapun, foreach loop biasanya memelihara tidak ada counter eksplisit : mereka pada dasarnya mengatakan "lakukan ini untuk semua yang ada di set ini", daripada "lakukan ini x kali". Ini menghindari potensi off-by-one error dan membuat kode lebih mudah dibaca.

Jadi konsep loop foreach menggambarkan bahwa loop tidak menggunakan penghitung eksplisit yang berarti bahwa tidak perlu menggunakan indeks untuk melintasi dalam daftar sehingga menghemat pengguna dari kesalahan satu per satu. Untuk menjelaskan konsep umum dari kesalahan satu-per-satu ini, mari kita ambil contoh loop untuk melintasi dalam daftar menggunakan indeks.

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

}

Tetapi anggaplah jika daftar dimulai dengan indeks 1 maka loop ini akan melempar pengecualian karena tidak akan menemukan elemen pada indeks 0 dan kesalahan ini disebut kesalahan satu-per-satu. Jadi untuk menghindari kesalahan off-by-one ini digunakan konsep foreach loop. Mungkin ada keuntungan lain juga, tapi inilah yang saya pikir adalah konsep utama dan keuntungan menggunakan foreach loop.

15

Perhatikan juga bahwa menggunakan metode "foreach" dalam pertanyaan asli memang memiliki beberapa keterbatasan, seperti tidak dapat menghapus item dari daftar selama iterasi.

For-loop baru lebih mudah dibaca dan menghilangkan kebutuhan untuk iterator yang terpisah, tetapi hanya benar-benar dapat digunakan dalam pass iterasi read-only.

9
billjamesdev

Menggunakan versi Java yang lebih lama termasuk Java 7 Anda dapat menggunakan foreach loop sebagai berikut.

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

Berikut ini adalah cara terbaru menggunakan loop foreach di Java 8

(loop Daftar dengan forEach + ekspresi lambda atau referensi metode)

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

Untuk info lebih lanjut lihat tautan ini.

https://www.mkyong.com/Java8/Java-8-foreach-examples/

9
Dulith De Costa

Inilah ekspresi yang setara.

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

Alternatif untuk forEach untuk menghindari "untuk masing-masing" Anda:

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

Varian 1 (biasa):

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

Varian 2 (eksekusi paralel (lebih cepat)):

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

Ini menambah keindahan kode Anda dengan menghapus semua kekacauan perulangan dasar. Ini memberikan tampilan bersih ke kode Anda, dibenarkan di bawah ini.

Normal for loop:

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

Menggunakan untuk masing-masing:

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

untuk-masing-masing adalah konstruk atas koleksi yang mengimplementasikan Iterator . Ingat bahwa, koleksi Anda harus menerapkan Iterator ; jika tidak, Anda tidak dapat menggunakannya dengan masing-masing.

Baris berikut dibaca sebagai " untuk setiap TimerTask t dalam daftar. "

for (TimerTask t : list)

Ada sedikit kemungkinan kesalahan dalam kasus untuk masing-masing. Anda tidak perlu khawatir tentang menginisialisasi iterator atau menginisialisasi penghitung lingkaran dan menghentikannya (jika ada ruang untuk kesalahan).

7
Manohar

Akan terlihat seperti ini. Sangat kekar.

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

Ada langgan yang baik pada untuk masing-masing dalam dokumentasi Sun .

6
Pete

Sebelum ke Java 8, Anda perlu menggunakan yang berikut:

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

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

Namun, dengan pengenalan Streams di Java 8 Anda dapat melakukan hal yang sama dalam sintaks yang jauh lebih sedikit. Misalnya, untuk someList Anda, Anda dapat melakukan:

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

Anda dapat menemukan lebih lanjut tentang stream di sini .

6
stackFan

Seperti yang dikatakan oleh begitu banyak jawaban yang baik, sebuah objek harus mengimplementasikan Iterable interface jika ingin menggunakan loop for-each.

Saya akan memposting contoh sederhana dan mencoba menjelaskan dengan cara yang berbeda bagaimana loop for-each bekerja.

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

Kemudian, jika kita menggunakan javap untuk mendekompilasi kelas ini, kita akan mendapatkan sampel bytecode ini:

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;

Seperti yang dapat kita lihat dari baris terakhir sampel, kompiler akan secara otomatis mengonversi penggunaan kata kunci for-each menjadi penggunaan Iterator pada waktu kompilasi. Itu mungkin menjelaskan mengapa objek, yang tidak mengimplementasikan Iterable interface, akan melempar Exception ketika mencoba menggunakan loop for-each.

5
L Joey

Di Java 8, mereka memperkenalkan forEach. Menggunakan Daftar itu, Peta dapat dilingkarkan.

Loop Daftar menggunakan untuk masing-masing

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

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

atau

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

Loop Peta menggunakan untuk masing-masing

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

atau

mapList.forEach((key,value)->{
    System.out.println("Key : " + key + " Value : " + value);
});
5
vivekkurien
public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}
3

Java untuk setiap loop (alias ditingkatkan untuk loop) adalah versi sederhana untuk loop. Keuntungannya adalah bahwa ada lebih sedikit kode untuk ditulis dan lebih sedikit variabel untuk dikelola. Kelemahannya adalah Anda tidak memiliki kendali atas nilai langkah dan tidak memiliki akses ke indeks loop di dalam tubuh loop.

Mereka paling baik digunakan ketika nilai langkah adalah peningkatan sederhana dari 1 dan ketika Anda hanya perlu akses ke elemen loop saat ini. Misalnya, jika Anda perlu mengulang semua elemen dalam array atau Koleksi tanpa mengintip ke depan atau di belakang elemen saat ini.

Tidak ada inisialisasi loop, tidak ada kondisi boolean dan nilai langkah implisit dan merupakan kenaikan sederhana. Inilah sebabnya mengapa mereka dianggap jauh lebih sederhana daripada yang biasa untuk loop.

Ditingkatkan untuk loop, ikuti urutan eksekusi ini:

1) loop body

2) ulangi dari langkah 1 hingga seluruh array atau koleksi telah dilintasi

Contoh - Integer Array

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

Variabel currentValue memegang nilai saat ini di-looped dalam array intArray. Perhatikan bahwa tidak ada nilai langkah eksplisit - itu selalu bertambah 1.

Usus besar dapat dianggap berarti "dalam". Jadi deklarasi loop yang disempurnakan menyatakan: loop over intArray dan menyimpan nilai int array saat ini in variabel currentValue.

Keluaran:

1
3
5
7
9

Contoh - String Array

Kita bisa menggunakan untuk-setiap loop untuk beralih di atas array string. Deklarasi loop menyatakan: loop over myStrings String array dan menyimpan nilai String saat ini in variabel currentString.

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

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

Keluaran:

alpha
beta
gamma
delta

Contoh - Daftar

Enhanced for loop juga dapat digunakan untuk beralih di atas Java.util.List sebagai berikut:

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

Deklarasi loop menyatakan: loop over myList List of Strings dan menyimpan nilai List saat ini in variabel currentItem.

Keluaran:

alpha
beta
gamma
delta

Contoh - Set

Enhanced for loop juga dapat digunakan untuk beralih di atas Java.util.Set sebagai berikut:

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

Deklarasi loop menyatakan: loop over mySet Set of Strings dan menyimpan nilai Set saat ini in variabel currentItem. Perhatikan bahwa karena ini adalah Set, nilai String duplikat tidak disimpan.

Keluaran:

alpha
delta
beta
gamma

Sumber: Loop di Jawa - Panduan Utama

3
gomisha

Java untuk-masing idiom hanya dapat diterapkan ke array atau objek bertipe * Iterable . Ungkapan ini adalah implisit karena benar-benar didukung oleh Iterator. Iterator diprogram oleh programmer dan sering menggunakan indeks integer atau node (tergantung pada struktur data) untuk melacak posisinya. Di atas kertas itu lebih lambat daripada loop biasa, paling tidak untuk struktur "linear" seperti array dan Daftar tetapi memberikan abstraksi yang lebih besar.

2
WIll

Ini terlihat gila tapi hei itu berhasil

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

Ini bekerja. Magic

1
Rei Brown