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

Klasik Üç Parçalı for Döngüsü

Bir for döngüsü, bir bloğu kontrollü sayıda kez tekrar eder. Java'nın biçimi, parantezlerin içine noktalı virgülle ayrılmış üç şeyi sığdırır:

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

Üç parça sabit bir ritimde çalışır:

1. İlklendirme (int i = 0) - her şeyden önce, bir kez çalışır.
2. Koşul (i < 5) - her geçişten önce kontrol edilir; koşul yanlış olduğunda döngü durur.
3. Güncelleme (i++) - her geçişten sonra, koşul yeniden kontrol edilmeden önce çalışır.

Yani bu, i = 0'dan i = 4'e kadar yazdırır. i sayacının kapsamı döngüyle sınırlıdır - kapanış küme parantezinden sonra var olmaz.

Yukarı, Aşağı ve Adımlarla Sayma

Üç parça sayaç üzerinde tam kontrol verir:

public class Main {
    public static void main(String[] args) {
        for (int i = 10; i > 0; i--) {       // geriye doğru say
            System.out.print(i + " ");
        }
        System.out.println();

        for (int i = 0; i <= 20; i += 5) {   // beşer adımla
            System.out.print(i + " ");
        }
    }
}

i-- azaltır, i += 5 beşer adımla atlar. Koşul, yöne duyarlı durmaya karar verir: geriye sayarken >, ileriye sayarken < veya <= kullan.

Bir Dizi Üzerinde Dönme

Sayaçlı bir döngü, sınır olarak .length'i ve indeks olarak i'yi kullanarak bir diziyle doğal şekilde eşleşir:

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        for (int i = 0; i < colors.length; i++) {
            System.out.println(i + ": " + colors[i]);
        }
    }
}

colors.length'in parantezsiz bir alan olduğuna dikkat et - diziler bu konuda özeldir. Bir List ise list.size() kullanır. i < colors.length koşulu doğrudur: indeksler 0'dan length - 1'e kadar gider, bu yüzden < kullanmak (<= değil) sınır dışı hatasını önler.

Geliştirilmiş for-each Döngüsü

Yalnızca her öğeye ihtiyacın olduğunda ve indekse asla ihtiyacın olmadığında, geliştirilmiş for daha temizdir ve yanlış yapması daha zordur - bir-eksik-bir-fazla hatası yapılacak sayaç yoktur:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> colors = List.of("red", "green", "blue");

        for (String color : colors) {
            System.out.println(color.toUpperCase());
        }
    }
}

for (String color : colors)'ı "colors içindeki her color için" diye oku. Diziler ve yinelenebilir her şey üzerinde çalışır. Bedeli: indeksin yoktur ve dönerken koleksiyona ekleme ya da koleksiyondan çıkarma yapamazsın (bu, ConcurrentModificationException fırlatır). İkisinden birine ihtiyacın olduğunda sayaçlı döngüye başvur.

İç İçe Döngüler

Bir döngünün içindeki döngü - ızgaralar, tablolar ve eşleştirmeler için kullanışlıdır. İç döngü, dış döngünün her geçişinde tam olarak çalışır:

public class Main {
    public static void main(String[] args) {
        for (int row = 1; row <= 3; row++) {
            for (int col = 1; col <= 3; col++) {
                System.out.print(row * col + "\t");
            }
            System.out.println();
        }
    }
}

Bu, 3x3'lük bir çarpım ızgarası yazdırır. İç içe geçme derinleştiğinde sayaçlara i, j yerine anlamlı adlar (row, col) ver - bu, hangisinin hangisi olduğunu karıştırmaktan seni kurtarır.

break ve continue

break döngüden hemen çıkar. continue, mevcut geçişin geri kalanını atlar ve güncelleme adımına geçer:

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue;   // çift sayıları atla
            if (i > 7) break;           // 7'yi geçince dur
            System.out.println(i);
        }
    }
}

Bu, 1 3 5 7 yazdırır. continue çiftleri atlar; break, i 7'yi aşacak olduğunda döngüyü bitirir. İç içe döngülerde, etiketli bir break kullanmadığın sürece her ikisi de yalnızca en içteki döngüyü etkiler.

Sonsuz Döngülere Dikkat

Koşul hiçbir zaman yanlış olmazsa, döngü sonsuza dek çalışır. Bunun her zamanki nedeni, güncellemeyi unutmak veya sayacı yanlış yöne hareket ettirmektir:

for (int i = 0; i < 5; i--) {   // i yalnızca azalır -> 5'e asla ulaşmaz
    System.out.println(i);
}

Kasıtlı bir sonsuz döngü üç parçanın hepsini atlar -for (;;) { ... }- ve durmak için içerideki bir break'e dayanır. Bunu tutumlu kullan; bir while (true) genellikle daha açık okunur.

Sonraki: while Döngüleri

for döngüsü, sayacı önceden bildiğinde parlar. Bir koşul değişene kadar dönmek istediğinde - ve elinde temiz bir sayaç yoksa - while döngüsü daha iyi oturur. Sıradaki sayfa bu.