Java while Döngüsü: Söz Dizimi, do-while ve Sık Yapılan Hatalar

Bir Sayacınız Olmadığında

for döngüsü, önceden kurduğunuz bir sayaç etrafında inşa edilir. Ama pek çok döngünün net bir sayısı yoktur: dosya bitene kadar satır okumaya devam etmek, doğru olana kadar parola istemeye devam etmek, 1'e ulaşana kadar bir sayıyı yarıya bölmeye devam etmek. Bu durumlar için while döngüsü doğal bir seçimdir; bir koşul doğru kaldığı sürece basitçe tekrar eder.

Bir while döngüsü, koşulunu her geçişten önce kontrol eder; ilk geçiş de buna dahildir. Koşul en baştan yanlışsa, gövde hiç çalışmaz.

public class Main {
    public static void main(String[] args) {
        int count = 3;

        while (count > 0) {
            System.out.println("Liftoff in " + count);
            count--;
        }

        System.out.println("Go!");
    }
}

Önce count > 0 koşulu kontrol edilir; doğruysa gövde çalışır; sonra başa döner ve tekrar kontrol ederiz. count-- satırı, koşulu eninde sonunda yanlış hale getiren şeydir; onu çıkarın ve döngü sonsuza dek çalışır.

Bir while Döngüsünün Anatomisi

Onu zaten bildiğiniz üç parçalı for döngüsüyle karşılaştırın. Bir while döngüsü bu üç işi birbirinden ayırır: kurulumu döngüden önce yaparsınız, koşul parantezlerin içine gider ve güncelleme gövdenin içinde yaşar.

int i = 0;              // başlatma - döngüden önce
while (i < 5) {         // koşul - her geçişte kontrol edilir
    System.out.println(i);
    i++;                // güncelleme - bunu kendiniz hatırlamalısınız
}

İşin püf noktası bu son kısım. Bir for döngüsünde güncelleme tam koşulun yanında durur, bu yüzden onu unutmak zordur. Bir while döngüsünde ise gövdedeki sıradan bir ifadedir; en sık yapılan hata onu dışarıda bırakıp programı kilitlemektir.

do-while: Gövdeyi En Az Bir Kez Çalıştır

Bazen tekrar edip etmeyeceğinize karar vermeden bile gövdenin bir kez önce çalışması gerekir. do-while döngüsü koşulunu en altta kontrol eder, bu yüzden gövde her zaman en az bir kez çalışır:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int number;

        do {
            System.out.print("Enter a positive number: ");
            number = in.nextInt();
        } while (number <= 0);

        System.out.println("Thanks! You entered " + number);
    }
}

Girdinin geçerli olup olmadığını bilmeden önce en az bir kez sormanız ve okumanız gerekir; do-while size tam olarak bunu verir. while (...) ifadesinden sonraki noktalı virgüle dikkat edin; o zorunludur ve onu unutmak sık görülen bir derleme hatasıdır.

Düz bir while ile farkı, koşul en baştan yanlış olduğunda açıkça ortaya çıkar:

public class Main {
    public static void main(String[] args) {
        int x = 10;

        // while: koşul en baştan yanlış -> gövde hiç çalışmaz
        while (x < 5) {
            System.out.println("while body");
        }

        // do-while: bir kez çalışır, SONRA kontrol eder -> gövde tam olarak bir kez çalışır
        do {
            System.out.println("do-while body");
        } while (x < 5);
    }
}

Yalnızca do-while body yazdırılır. while döngüsü gövdesini tamamen atlar çünkü x < 5 ilk kontrolden önce yanlıştı.

Bir Nöbetçi Değere Kadar Döngü Kurma

while için klasik bir kullanım, özel bir "dur" değerine kadar okumaktır; bir nöbetçi (sentinel). Burada bir sayaç yoktur; veriler size durmanızı söyleyene kadar devam edersiniz:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = 0;

        System.out.println("Enter numbers to add (0 to finish):");
        int value = in.nextInt();

        while (value != 0) {
            sum += value;
            value = in.nextInt();
        }

        System.out.println("Total: " + sum);
    }
}

Bu kalıp şöyledir: döngüden önce bir kez oku, sonra her geçişin sonunda tekrar oku. Böylece koşul her zaman taze girdiyi test eder. Gövdenin içindeki ikinci okumayı unutursanız, value asla değişmez ve sonsuz bir döngünüz olur.

while Döngülerinde break ve continue

break ve continue burada bir for döngüsündeki gibi çalışır. break döngüden hemen çıkar; continue doğrudan koşul kontrolüne atlar ve mevcut geçişin geri kalanını atlar:

public class Main {
    public static void main(String[] args) {
        int n = 0;

        while (true) {              // kasıtlı "sonsuz döngü"
            n++;
            if (n % 2 == 0) continue;   // çift sayıları atla
            if (n > 9) break;           // 9'u geçince dur
            System.out.println(n);
        }
    }
}

Bu, 1 3 5 7 9 yazdırır. while (true) kasıtlı olarak kendiliğinden asla durmaz; tek çıkış break'tir. Bir while döngüsünde continue ile dikkatli olun: güncelleme gövdenin bir parçası olduğundan, sayacınızı ilerletmeden önce continue ile başa atlamak döngüyü sessizce kilitlemenin bir yoludur. Yukarıdaki örnekte n++ önce çalışır, bu yüzden güvenlidir.

Sonsuz Döngülere Dikkat Edin

Koşulun eninde sonunda yanlış hale gelmesi gerekir ve bu tamamen gövdenin içindeki bir şeyin değişmesine bağlıdır. İki olağan şüpheli güncellemeyi unutmak ve yanlış şekilde güncellemektir:

int i = 0;
while (i < 5) {
    System.out.println(i);   // i hiç değişmez -> sonsuza dek çalışır
}

int i = 0;
while (i != 10) {
    i += 3;   // 0, 3, 6, 9, 12... 10'u tam atlar -> sonsuza dek çalışır
}

İlki kilitlenir çünkü i hiç güncellenmez. İkincisi kilitlenir çünkü sayaç koşulun aradığı tam değerin üzerinden atlar; adım tam olarak denk gelmeyebilecekse != yerine < veya <= tercih edin. Bir while (true), garantili bir break'i varsa sorun değildir; kazara olanı ise sadece bir hatadır.

Sonraki: for-each Döngüsü

Bir while döngüsü, bir koşul değişene kadar döngü kurarken ve net bir sayı yokken doğru araçtır. Ama yalnızca bir dizinin veya listenin her elemanını ziyaret etmek istediğinizde (indeks yok, yönetilecek koşul yok) daha da temiz bir şey vardır: gelişmiş for-each döngüsü. Sıradaki sayfa bu.