for-each Loop Java: Sintaks, Contoh, dan Jebakannya

Saat Index Justru Mengganggu

for loop dengan penghitung memberimu penghitung, kondisi, dan langkah pembaruan. Tetapi sering sekali kamu sebenarnya tidak peduli pada posisi sebuah elemen. Kamu hanya ingin melakukan sesuatu pada setiap elemen, berurutan, dari awal sampai akhir. Mengurus index untuk itu hanyalah pekerjaan tambahan, dan justru di situlah bug selisih satu (off-by-one) diam-diam masuk.

For-each loop (Java menyebutnya for versi enhanced) sama sekali tidak memakai penghitung. Kamu memberi nama sebuah variabel, mengarahkannya ke sebuah collection, dan loop menyerahkan setiap elemen secara bergantian.

Sintaks Dasar

Bentuknya for (Type element : collection). Baca titik duanya sebagai kata "di dalam":

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 100};

        for (int score : scores) {
            System.out.println("Score: " + score);
        }
    }
}

Tidak ada i, tidak ada scores.length, tidak ada scores[i]. Di setiap putaran, score adalah elemen berikutnya. Loop berjalan sekali untuk setiap elemen dan berhenti otomatis saat elemennya habis: kamu tidak mungkin berjalan melewati ujung atau mulai satu elemen terlalu awal.

Perulangan pada List

Loop yang sama bekerja pada apa pun yang iterable, termasuk List, Set, dan tipe collection lainnya. Tipe elemennya ditulis sebelum nama variabel:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang + " has " + lang.length() + " letters");
        }
    }
}

Perhatikan bahwa kamu tidak perlu tahu atau peduli apakah langs didukung oleh array, linked list, atau yang lainnya: for-each bekerja dengan cara yang sama pada semuanya. Itulah kekuatannya yang sebenarnya: satu sintaks yang mudah dibaca untuk setiap collection.

var Menghemat Penulisan Nama Tipe

Kalau tipe elemennya panjang atau sudah jelas, var membuat compiler menyimpulkannya sehingga kamu tidak perlu mengulang-ulang:

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.of("Ann", 30, "Bo", 25);

        for (var entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Tanpa var, variabel loop itu harus ditulis sepanjang Map.Entry<String, Integer>. var membuatnya tetap mudah dibaca, dan tipenya tetap diperiksa sepenuhnya saat kompilasi: ini bukan tipe dinamis yang longgar.

Jebakan Mengubah Collection

Inilah aturan yang menjebak semua orang: kamu tidak bisa menambah atau menghapus elemen dari sebuah collection saat for-each loop sedang menelusurinya. Kalau kamu melakukannya, Java melempar ConcurrentModificationException:

List<String> items = new ArrayList<>(List.of("a", "b", "c"));

for (String item : items) {
    if (item.equals("b")) {
        items.remove(item);   // throws ConcurrentModificationException
    }
}

Loop menyadari bahwa list-nya berubah di tengah jalan dan memilih berhenti daripada diam-diam melewatkan atau mengulang elemen. Untuk menghapus dengan aman, turunlah ke Iterator eksplisit, yang punya remove() yang dikenali oleh loop:

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

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("a", "b", "c"));

        Iterator<String> it = items.iterator();
        while (it.hasNext()) {
            if (it.next().equals("b")) {
                it.remove();   // safe
            }
        }

        System.out.println(items);   // [a, c]
    }
}

Jalan pintas yang umum adalah items.removeIf(item -> item.equals("b")), yang memakai lambda expression untuk melakukan hal yang sama dalam satu baris.

Hanya Membaca, Bukan Mengganti

Batasan halus lainnya: memberi nilai baru ke variabel loop hanya mengubah salinan lokalnya, bukan collection-nya. Ini mengejutkan orang yang datang dari bahasa yang variabel loop-nya berupa referensi langsung:

public class Main {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};

        for (int n : nums) {
            n = n * 10;   // changes the copy, not the array
        }

        System.out.println(nums[0]);   // still 1
    }
}

Kalau kamu perlu menulis kembali ke array, kamu butuh index-nya, dan itu berarti for loop klasik dengan penghitung: for (int i = 0; i < nums.length; i++) nums[i] = nums[i] * 10;. Untuk elemen berupa objek, kamu bisa mengubah objek yang ditunjuk variabel itu (misalnya dengan memanggil setter), tetapi kamu tidak bisa menggantinya di dalam collection.

break dan continue Tetap Berfungsi

For-each adalah loop sungguhan, jadi break dan continue berperilaku persis sama seperti di tempat lain: break keluar dari loop, continue melompat ke elemen berikutnya:

public class Main {
    public static void main(String[] args) {
        String[] words = {"keep", "skip", "keep", "stop", "never"};

        for (String w : words) {
            if (w.equals("skip")) continue;   // ignore this one
            if (w.equals("stop")) break;      // quit entirely
            System.out.println(w);
        }
    }
}

Ini mencetak keep lalu keep: ia melewati "skip" dan berhenti di "stop" sebelum sampai ke "never". Jadi kamu tidak terpaksa mengunjungi setiap elemen; kamu hanya melepas index sebagai ganti kode yang lebih rapi.

Berikutnya: Array

Kamu sudah beberapa kali menelusuri array tanpa membahas apa sebenarnya array itu: wadah berukuran tetap dan ber-index dengan field .length. Halaman berikutnya kembali ke awal dan membahas array dengan tuntas: cara mendeklarasikannya, nilai default awalnya, dan bagaimana ukurannya yang tetap berbeda dengan ArrayList yang bisa bertambah.