Java for-each Döngüsü: Söz Dizimi, Örnekler ve Tuzaklar

İndeks Yalnızca Ayak Bağı Olduğunda

Sayaçlı bir for döngüsü sana bir sayaç, bir koşul ve bir güncelleme adımı verir. Ama çoğu zaman aslında bir elemanın konumu umurunda değildir; sadece her birine sırayla, baştan sona bir şeyler yapmak istersin. Bunun için bir indeks yönetmek boş iştir ve birer fazla/eksik (off-by-one) hataları tam da buraya sızar.

for-each döngüsü (Java'nın ona verdiği ad gelişmiş for) sayacı tamamen kaldırır. Bir değişken adlandırır, onu bir koleksiyona yöneltirsin ve döngü sana her elemanı sırayla verir.

Temel Söz Dizimi

Şekli for (Tip eleman : koleksiyon) biçimindedir. İki noktayı "içindeki" kelimesi gibi oku:

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

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

i yok, scores.length yok, scores[i] yok. Her geçişte score zaten bir sonraki elemandır. Döngü her eleman için bir kez çalışır ve eleman kalmadığında otomatik olarak durur; sonu geçemez veya bir eleman erken başlayamazsın.

Bir Liste Üzerinde Dönme

Aynı döngü, List, Set ve diğer koleksiyon türlerini de kapsayan yinelenebilir her şeyle çalışır. Eleman tipi değişken adından önce gelir:

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

langs'in bir diziyle mi, bağlı listeyle mi yoksa başka bir şeyle mi desteklendiğini bilmen veya umursaman gerekmediğine dikkat et; for-each hepsinde aynı şekilde çalışır. Asıl gücü budur: her koleksiyon için tek bir okunabilir söz dizimi.

var Sana Tip Adını Yazma Zahmetini Kaldırır

Eleman tipi uzun veya bariz ise, var derleyicinin onu çıkarsamasını sağlar, böylece kendini tekrarlamazsın:

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

var olmadan o döngü değişkeni ağız dolusu Map.Entry<String, Integer> olurdu. var onu okunabilir tutar ve tip yine de derleme zamanında tamamen denetlenir; bu, gevşek, dinamik bir tip değildir.

Değiştirme Tuzağı

İşte herkesi yakalayan kural: bir for-each döngüsü bir koleksiyonu dolaşırken ona eleman ekleyemez veya çıkaramazsın. Bunu yapmak bir ConcurrentModificationException fırlatır:

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

for (String item : items) {
    if (item.equals("b")) {
        items.remove(item);   // ConcurrentModificationException fırlatır
    }
}

Döngü, listenin altından değiştiğini fark eder ve elemanları sessizce atlamak veya tekrarlamak yerine durur. Güvenle silmek için, döngünün haberdar olduğu bir remove() metoduna sahip açık bir Iterator'a in:

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();   // güvenli
            }
        }

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

Sık kullanılan bir kısayol, aynı işi tek satırda yapan items.removeIf(item -> item.equals("b"))tir.

Yalnızca Okuma, Yeniden Atama Yok

Bir başka ince sınır: döngü değişkenine atama yapmak yalnızca yerel kopyayı değiştirir, koleksiyonu değil. Bu, döngü değişkeninin canlı bir referans olduğu dillerden gelenleri şaşırtır:

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

        for (int n : nums) {
            n = n * 10;   // kopyayı değiştirir, diziyi değil
        }

        System.out.println(nums[0]);   // hâlâ 1
    }
}

Diziye geri yazman gerekiyorsa indekse ihtiyacın var ve bu da klasik sayaçlı for döngüsü demektir: for (int i = 0; i < nums.length; i++) nums[i] = nums[i] * 10;. Nesne elemanları için, değişkenin işaret ettiği nesneyi (örneğin bir setter çağırarak) değiştirebilirsin, ama onu koleksiyondaki yerinde başkasıyla değiştiremezsin.

break ve continue Hâlâ Çalışır

Bir for-each gerçek bir döngüdür, bu yüzden break ve continue her yerdeki gibi davranır: break döngüden çıkar, continue bir sonraki elemana atlar:

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;   // bunu yok say
            if (w.equals("stop")) break;      // tamamen çık
            System.out.println(w);
        }
    }
}

Bu keep ve ardından keep yazdırır: "skip"i atlar ve "never"a ulaşmadan "stop"ta durur. Yani her elemanı ziyaret etmeye mahkûm değilsin; sadece daha temiz kod karşılığında indeksten vazgeçersin.

Sonraki: Diziler

Artık dizileri gerçekte ne olduklarına takılmadan birkaç kez dolaştın: o .length alanına sahip sabit boyutlu, indeksli kaplar. Sonraki sayfa başa döner ve dizileri gerektiği gibi ele alır: onları nasıl bildireceğin, başladıkları varsayılan değerler ve sabit boyutlarının büyüyebilen bir ArrayList'ten nasıl farklı olduğu.