Java Döngüleri: for, while ve do-while Rehberi

Java döngüleri, aynı işlemi tekrar tekrar yazmak yerine belirli bir kurala göre otomatik olarak çalıştırmanızı sağlar. for belirli tekrar sayıları ve sayaçlar için, while bir koşul sağlandığı sürece devam eden işlemler için, do-while ise gövdenin en az bir kez çalışması gereken durumlar için tercih edilir.

Bir döngü kurulurken dört temel noktayı düşünmek gerekir: başlangıç değeri nerede verilecek, koşul ne zaman kontrol edilecek, tekrar eden işlem ne olacak ve her turdan sonra hangi değer güncellenecek?

Java’da Döngü Nedir ve Neden Kullanılır?

Örneğin 1’den 3’e kadar sayıları ekrana yazdırmak istediğinizi düşünün. Döngü kullanmadan her satırı ayrı yazabilirsiniz:

System.out.println(1);
System.out.println(2);
System.out.println(3);

Bu yaklaşım kısa örneklerde çalışsa da tekrar sayısı arttığında kodu uzatır ve değiştirmeyi zorlaştırır. Aynı işi bir döngüyle daha düzenli biçimde ifade edebilirsiniz:

for (int number = 1; number <= 3; number++) {
    System.out.println(number);
}

Burada number başlangıçta 1 değerini alır. Koşul doğru olduğu sürece gövde çalışır; ardından number++ ifadesi sayacı bir artırır. Sayaç 4 olduğunda number <= 3 koşulu yanlış olur ve döngü sona erer. Bu akış, döngülerin temel çalışma mantığını oluşturur.

for Döngüsü: Tekrar Sayısı Bilinen İşlemler

for döngüsü, kaç kez tekrar yapılacağının bilindiği veya bir sayacın düzenli olarak ilerlediği durumlarda en okunabilir seçeneklerden biridir. Yapısında üç bölüm bulunur:

• Başlangıç: Sayaç veya kullanılacak değişken oluşturulur.
• Koşul: Her turdan önce kontrol edilir. Koşul doğruysa gövde çalışır.
• Güncelleme: Her turun sonunda sayaç artırılır, azaltılır veya başka bir şekilde değiştirilir.

Aşağıdaki örnek 1’den 5’e kadar olan sayıları yazdırır:

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

Beklenen çıktı:

1
2
3
4
5

Bu örnekte sayaç her turda bir artar. number <= 5 koşulu, 5 değerinin de yazdırılmasını sağlar. Koşulu number < 5 biçiminde yazsaydınız çıktı 1, 2, 3 ve 4 ile sınırlı kalırdı. Bu tür sınır hataları, özellikle başlangıç ve bitiş değerleri dikkatle belirlenmediğinde ortaya çıkar.

for döngüsü yalnızca sayı yazdırmak için kullanılmaz. Bir dizinin elemanlarına indeks üzerinden erişirken de yaygın biçimde kullanılır:

String[] colors = {"Kırmızı", "Mavi", "Yeşil"};

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

Dizilerde indeksler 0’dan başladığı için ilk elemana colors[0] ile erişilir. Son geçerli indeks, dizinin uzunluğundan bir eksiktir. Bu nedenle koşulun index < colors.length olması gerekir; index <= colors.length yazmak, sınırın dışındaki elemana erişmeye çalışarak hata oluşturabilir.

• Tekrar sayısı belliyse for kullanın.
• Bir sayaçla ilerliyorsanız başlangıç, bitiş ve artış miktarını aynı satırda görünür tutun.
• Dizi üzerinde gezerken indeksin 0’dan başladığını ve koşulun uzunluktan küçük olması gerektiğini unutmayın.

Java temellerini daha planlı ve uygulamalı öğrenmek isteyenler için Java özel ders programı, döngülerden nesne yönelimli programlamaya kadar konuları kişiye özel bir sırayla çalışmaya yardımcı olabilir.

while ve do-while Döngüleri Nasıl Ayrılır?

while döngüsünde koşul, döngü gövdesinden önce kontrol edilir. Bu nedenle koşul ilk kontrolde yanlışsa gövde hiç çalışmaz. Tekrar sayısının önceden bilinmediği ve işlemin bir durum doğru kaldığı sürece devam etmesi gereken senaryolarda kullanışlıdır.

public class WhileOrnegi {
    public static void main(String[] args) {
        int sayi = 1;

        while (sayi <= 3) {
            System.out.println("Sayaç: " + sayi);
            sayi++;
        }
    }
}

Beklenen çıktı:

Sayaç: 1
Sayaç: 2
Sayaç: 3

Bu örnekte döngünün kaç kez çalışacağını matematiksel olarak hesaplayabilirsiniz; ancak while genellikle kullanıcı doğru bilgi girene, bir dosyada veri kaldığı sürece veya bir işlem tamamlanana kadar devam eden akışlarda tercih edilir. Önemli nokta, döngü içinde koşulu etkileyen değişkenin güncellenmesidir.

do-while döngüsünde ise gövde önce çalışır, koşul sonra kontrol edilir. Bu yüzden gövde, koşul başlangıçta yanlış olsa bile en az bir kez yürütülür. Kullanıcıdan giriş alma, menüyü en az bir kez gösterme veya bir işlemi denedikten sonra devam edip etmeye karar verme gibi durumlarda uygundur.

import java.util.Scanner;

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

        do {
            System.out.print("Çıkmak için 0 girin: ");
            cevap = scanner.nextInt();
        } while (cevap != 0);

        System.out.println("Program sonlandı.");
        scanner.close();
    }
}

Bu örneği çalıştırmak için Scanner sınıfını içeren import java.util.Scanner; satırı gereklidir. Kullanıcı ilk girişte 0 yazsa bile soru bir kez gösterilir. Buna karşılık aynı başlangıç koşuluyla yazılan bir while döngüsü, koşul ilk kontrolde yanlış olduğu için hiç giriş istemeden sonlanabilirdi.

Üç Döngüyü Karşılaştırma ve Doğru Döngüyü Seçme

Örneğin bir sayı tahmin oyununda oyuncunun kaç denemede doğru cevabı bulacağı önceden bilinmez. Bu nedenle sabit tekrar sayısına dayanan for yerine koşula bağlı bir döngü düşünülür. Java temellerindeki koşul ve döngü bilgilerinizi ölçmek için Java bilgi testi üzerinden benzer kararları uygulamalı olarak değerlendirebilirsiniz.

1. Tekrar sayısı biliniyor mu? Evetse for seçimini değerlendirin. Örneğin 12 aylık satış verisini sırayla incelemek için başlangıç, bitiş ve artış değeri bellidir.
2. İşlem en az bir kez çalışmalı mı? Evetse do-while seçimini değerlendirin. Bir menünün kullanıcıdan seçim almadan önce en az bir kez gösterilmesi gerekir.
3. İşlem yalnızca koşul sağlandığı sürece mi devam etmeli? Evetse while seçimini değerlendirin. Tahmin oyunu doğru cevap gelene kadar sürebilir; ancak oyuncu ilk anda doğru tahmin etmişse tekrar sayısını önceden belirlemek mümkün değildir.

break, continue ve Yaygın Döngü Hatalarını Teşhis Etme

break döngüyü tamamen bitirir; continue ise mevcut turdaki kalan kodu atlayıp bir sonraki tura geçer. Bu ifadeler akışı gerçekten sadeleştirdiğinde kullanılmalı, her koşulda kontrol akışını parçalamak için tercih edilmemelidir.

break ve continue nasıl kullanılır?

for (int number = 1; number <= 10; number++) {
    if (number == 7) {
        break;
    }
    if (number % 2 == 0) {
        continue;
    }
    System.out.println(number);
}

Bu kodda döngü 7 sayısına geldiğinde tamamen sonlanır. Çift sayılarda ise continue çalışır ve yazdırma işlemi atlanır. Beklenen çıktı 1, 3 ve 5 değerleridir. Ancak aynı mantık basit bir koşulla daha okunaklı kurulabiliyorsa break ve continue kullanmak yerine koşulu doğrudan döngü gövdesinde ifade etmek daha iyi olabilir.

Sonsuz döngü: Sayaç güncellenmiyor

int count = 1;

while (count <= 3) {
    System.out.println(count);
    count++; // Güncelleme yapılmazsa döngü sonsuza gidebilir.
}

• Belirti: Program aynı işlemi tekrar tekrar yapar veya hiç sonlanmaz.
• Neden: Döngü koşulunda kullanılan count değişkeni her turda değişmiyordur.
• Düzeltme: Sayaç güncellemesini görünür bir noktaya ekleyin ve döngünün hangi değerde biteceğini kontrol edin.

Koşulun hiç sağlanmaması

int start = 10;

while (start < 5) {
    System.out.println(start);
    start--;
}

• Belirti: Döngü gövdesi hiç çalışmaz.
• Neden: Başlangıç değeri 10, koşul ise 5’ten küçük olmasını bekliyor. İlk kontrolde koşul yanlıştır.
• Düzeltme: Başlangıç değerini ve koşulun yönünü birlikte değerlendirin. Azalan bir sayaç için start >= 5 gibi uygun bir koşul gerekebilir.

Off-by-one hatası: < ve <= farkı

i < 5 koşulu 0, 1, 2, 3 ve 4 değerlerini işler; i <= 5 ise 5’i de dahil ederek bir tur fazla çalışır.

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}
// Çıktı: 0 1 2 3 4

• Belirti: Bir eleman eksik işlenir veya dizi sınırı aşılır.
• Neden: Başlangıç ve bitiş sınırlarının dahil olup olmadığı karıştırılmıştır.
• Düzeltme: “Kaç tur?” yerine “Hangi değerler işlenecek?” sorusunu sorun. Dizi indekslerinde çoğunlukla index < array.length biçimi güvenlidir.

Okunabilir ve Güvenli Döngüler Yazmak

Güvenli bir döngü yalnızca çalışan değil, başka bir kişinin baktığında amacını anlayabildiği döngüdür. Koddan önce düşünme yaklaşımında önce başlangıç durumunu, devam koşulunu ve her turdaki değişimi belirlemek gerekir. Bu yaklaşım, eğitmenimiz Berk Keskin'in canlı Java temelleri eğitimi kapsamında vurgulanan sistemli problem çözme alışkanlığıyla uyumludur.

• Anlamlı isimler kullanın: i yerine studentIndex, retryCount veya totalScore gibi amaç belirten isimler seçin.
• Koşulu sade kurun: Bir bakışta ne zaman devam edileceği anlaşılmalıdır.
• Güncellemeyi görünür tutun: Sayaç değişimini karmaşık bir metodun içine saklamayın.
• İç içe döngüyü gerekçelendirin: Tablo, matris veya koordinat düzlemi gibi iki boyutlu verilerde iç içe döngü anlamlıdır. Sadece tek bir koşulu kontrol etmek için kullanılması gereksiz karmaşıklık oluşturur.
• Karmaşık gövdeyi bölün: Döngü içinde çok fazla hesaplama varsa işlemi yardımcı bir metoda ayırın.

Son kontrolde şu soruları sırayla yanıtlayın:

1. Döngü kesin olarak sonlanıyor mu?
2. Başlangıç ve bitiş sınırları doğru mu?
3. Değişken adı amacını anlatıyor mu?
4. break veya continue gerçekten gerekli mi?

Sık Sorulan Sorular

Java’da for ve while döngüsü arasında nasıl seçim yapılır?

Tekrar sayısı veya sayaç yapısı baştan belliyse for, koşulun ne zaman değişeceği süreç içinde belirleniyorsa while tercih edilir.

do-while döngüsü neden en az bir kez çalışır?

Çünkü do-while yapısında önce gövde çalıştırılır, koşul daha sonra kontrol edilir. Bu nedenle başlangıç koşulu yanlış olsa bile ilk tur gerçekleşir.

Java’da sonsuz döngü nasıl oluşur ve nasıl durdurulur?

Genellikle koşulda kullanılan sayaç güncellenmediğinde veya koşul hiçbir zaman yanlış olmayacak şekilde kurulduğunda oluşur. Güncelleme işlemini kontrol edin; gerekirse güvenli bir bitiş koşulu ekleyin.

break ile continue arasındaki fark nedir?

break döngüyü tamamen sonlandırır. continue yalnızca mevcut turun kalan kısmını atlar ve sonraki tura geçer.

Java döngülerinde off-by-one hatası nasıl önlenir?

< ve <= farkını açıkça değerlendirin. Kaç tur çalışacağını değil, hangi değerlerin işleneceğini yazarak sınırları test edin.

Döngü yazarken önce akışı kâğıt üzerinde veya kısa bir örnekle simüle etmek, hataları sonradan düzeltmekten daha kolaydır.