CodeGym /Java Blogu /Rastgele /while ifadesi
John Squirrels
Seviye
San Francisco

while ifadesi

grupta yayınlandı
İlk programlarımız birbiri ardına yürütülen bir dizi talimattı. Çatal yok. Bu, bir selamlama görüntüleyen HelloWorld'ü içerir. Aritmetik hesaplamaları içerir. İlk programlarımızdan sonra dallanmayı, yani belirli koşullara bağlı olarak bir programın farklı eylemler gerçekleştirmesini sağlamayı öğrendik. İşte bir merkezi ısıtma ve iklimlendirme sistemini kontrol etmek için kullanılan kod:

if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort)
    heaterOn();
Bir sonraki adımı atın. Günlük yaşamda, örneğin bir turta için elma soymak gibi tek tip tekrarlayan eylemler gerçekleştiririz. Bu büyüleyici süreç şu şekilde tanımlanabilir:
  1. Kasede elma varsa, 1.1'den 1.4'e kadar olan adımları uygularız:

    1. 1.1. bir elma kap
    2. 1.2. Soyup dilimler halinde kesin
    3. 1.3. Elma dilimlerini turta kabuğuna bir tavada düzenleyin
    4. 1.4. 1. adıma dönün.
while ifadesi - 2Diyelim ki on elma, iki el ve bir bıçağınız var. Gerçek hayatta, her elma için aynı algoritmayı izleyerek sırayla tüm düzineyi soyarsınız. Ancak bir programın her elma için tekrarlayan bir eylem yapmasını nasıl sağlarız?
  • Kendimizi elma sayısına bağlıyoruz, ancak yeterince elmamız yoksa, bazı komutlar "yük" olmadan yürütülür (ve olmayan bir elmayı soymaya çalışırken kendimizi kesebiliriz).
  • Soyma komutlarından daha fazla elma varsa, o zaman elmaların bir kısmı soyulmadan kalır.
  • Böyle bir kodun okunması zordur. Çok sayıda tekrarı vardır ve değiştirilmesi zordur.

Döngüler, eylemlerin tekrar tekrar gerçekleştirilmesine izin veren ifadelerdir.

Java'nın while döngüsü bizim durumumuzda iyi çalışacaktır. Bu yapı, birden çok eylemi özlü ve anlaşılır bir yapıya yerleştirir. Bir süre döngüsü kullanarak , bir turta için bir elma dilimleme algoritması Java'da şöyle görünebilir:

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    arrangeInPie(apple.peel().slice());
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");

Komut sözdizimi

while ifadesinin ilk varyantı şu şekildedir:

while (Boolean expression) {
	// Loop body — the statement(s) that are repeatedly executed
}
İşte bu kod yürütüldüğünde ne olduğunun adım adım açıklaması:
  1. While anahtar kelimesinden sonra parantez içinde bulunan Boole ifadesini değerlendiriyoruz .
  2. Boolean ifadesi true olarak değerlendirilirse, döngü gövdesindeki ifadeler yürütülür. Döngü gövdesindeki son ifade çalıştırıldıktan sonra 1. adıma geçilir.
  3. Boolean ifadesi false olarak değerlendirilirse, while döngüsünden sonraki ilk ifadeye atlarız .

Önkoşullu döngü

Döngü gövdesini yürütmeden önce her zaman Boolean ifadesini (döngüye girme koşulu) değerlendirdiğimiz için , while döngüsünün bu biçimi genellikle önkoşullu bir döngü olarak adlandırılır . Bir sayının ilk on kuvvetinin tablosunu oluşturalım:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (exponent <= 10) { // The condition for entering the loop
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
    }
}
Konsol çıktısı:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

Son koşullu döngü

İşte bu döngünün ikinci çeşidi:

do {
    // Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
İşte bu kod yürütüldüğünde ne olduğunun bir açıklaması:
  1. Döngü gövdesi yürütülür ( do anahtar sözcüğünden hemen sonra).
  2. While anahtar kelimesinden sonra parantez içinde bulunan Boole ifadesini değerlendiriyoruz .
  3. Boolean ifadesi true olarak değerlendirilirse 1. adıma geçilir.
  4. Boolean ifadesi false olarak değerlendirilirse, while döngüsünden sonraki ilk ifadeye atlarız .
Önceki döngüden iki ana fark şunlardır: 1) döngü gövdesi en az bir kez yürütülür ve 2) Boolean ifadesi, döngü gövdesi yürütüldükten sonra değerlendirilir. Buna göre, bu tür bir while döngüsüne sonkoşullu bir döngü denir . Bu sefer 10000'i aşmayan bir sayının bir üsler tablosunu görüntüleyeceğiz:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = base; // The result of exponentiation
    int exponent = 1; // The initial exponent
    do {
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        result = result * base;
    } while (result < 10000); // The condition for exiting the loop
}
Konsol çıktısı:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0
Koddaki değişikliklere dikkat edin. Bunu bir önkoşullu döngü ile karşılaştırın.

Döngülerle çalışma hakkında ilginç gerçekler

Döngü gövdesi içindeki dallanma ifadeleri

Bir döngü içinde yürütmeyi etkileyen iki ifade vardır: break (bir sonraki bölümde daha ayrıntılı olarak tartışacağız) ve devam etmek.
  • devam et — geçerli yinelemede döngü gövdesinin geri kalanının yürütülmesini atlar ve while ifadesinin Boolean ifadesinin değerlendirilmesine atlar. İfade true olarak değerlendirilirse döngü devam eder.
  • break — geçerli yinelemenin yürütülmesini hemen sonlandırır ve kontrolü döngüden sonraki ilk ifadeye aktarır. Böylece, bu ifade mevcut döngünün yürütülmesini sonlandırır. Bir sonraki makalede daha ayrıntılı olarak ele alacağız.
Meyve örneğimizi hatırlayın. Elmaların kalitesinden emin değilsek, devam deyimi kullanarak kodu değiştirebiliriz :

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
    if (apple.isBad()) { // This method returns true for rotten apples
        apple.throwInGarbage();
        continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
    }
    arrangeInPie(apple.peel().slice());
}
Devam deyimi, genellikle , belirli bir koşulun karşılanması durumunda döngü gövdesindeki deyimlerin yürütülmesi gerektiğinde kullanılır. Örneğin, bir donanım sensörü tetiklendiğinde eylemler gerçekleştirmek isteyebiliriz (aksi takdirde, sensör okumalarını aldığımız döngüye devam etmek yeterlidir) veya bir döngünün yalnızca belirli yinelemelerinde bir ifade hesaplamak isteyebiliriz. İkinci durumun bir örneği, karesi sayıların sayısından küçük olan doğal sayıların küplerinin toplamını hesaplamak için bir while döngüsünü kullanmamızda görülebilir. Kafası karışmış? Aşağıdaki kodu inceleyin:

public static void main(String[] args) {
    int sum = 0;  // Total amount
    int i = 0;  // Initial number in the series
    int count = 20;  // Number of numbers
    while (i <= count) {
        i++;  // Get the next number — "i++" is equivalent to "i = i + 1"
        if (i * i <= count)  // If the square of the number is less than
            continue;  // the number of numbers, then we won't calculate the sum
                            // Jump to the next number in the loop
        sum += i * i * i;  // Otherwise, we calculate the sum of the cubes of numbers
    }  // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
    System.out.println(sum);  // Print the result
}

Sonsuz döngü

Bu dallanma ifadeleri en çok sonsuz döngülerde kullanılır. Döngüden çıkmak için Boole koşulu hiçbir zaman karşılanmazsa döngüye sonsuz diyoruz. Kodda şöyle bir şeye benziyor:

while (true) {
    // Loop body 
}
Bu durumda, bir break ifadesi döngüden çıkmamıza yardımcı olur. Bu tip bir döngü, döngü gövdesi dışında belirlenen dış koşulları beklerken uygundur. Örneğin, işletim sistemlerinde veya oyunlarda (döngüden çıkmak, oyundan çıkmak anlamına gelir). Veya bir döngünün her yinelemesinde bazı sonuçları iyileştirmeye çalışan, ancak yineleme sayısını geçen zamana veya harici bir olayın oluşumuna (örn. dama, satranç veya hava tahmini) göre sınırlayan algoritmalar kullanırken. Normal koşullar altında sonsuz döngülerin istenmediğini unutmayın. Göstermek için, üs almaya geri dönelim:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (true) {
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        if (exponent > 10)
            break; // Exit the loop
    }
}
Konsol çıktısı:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

İç içe geçmiş döngüler

Ve şimdi döngülerle ilgili son konumuza geldik. O elmalı turtayı (umarım şu anda aç değilsinizdir) ve elma soyma döngümüzü hatırlayın:
  1. Kasede elma varsa, 1.1'den 1.4'e kadar olan adımları uygularız:

    1. 1.1. bir elma kap
    2. 1.2. Soyup dilimler halinde kesin
    3. 1.3. Elma dilimlerini turta kabuğuna bir tavada düzenleyin
    4. 1.4. 1. adıma dönün.
Dilimleme işlemini daha ayrıntılı olarak açıklayalım:
  1. Dilim sayısı = 0
  2. Dilim sayısı < 12 olduğu sürece 2.1 ile 2.3 arasındaki adımları uygulayın

    1. 2.1. Elmadan bir dilim daha kesin
    2. 2.2. dilim sayısı++
    3. 2.3. 2. adıma dön
Ve bunu pasta yapma algoritmamıza ekleyeceğiz:
  1. Kasede elma varsa, 1.1'den 1.6'ya kadar olan adımları uygularız:

    1. 1.1. bir elma kap
    2. 1.2. Onu soy
    3. 1.3. Dilim sayısı = 0
    4. 1.4. Dilim sayısı < 12 olduğu sürece 1.4.1'den 1.4.3'e kadar olan adımları gerçekleştirin
      1. 1.4.1. Elmadan bir dilim daha kesin
      2. 1.4.2. dilim sayısı++
      3. 1.4.3. Adım 1.4'e dön
    5. 1.5. Elma dilimlerini turta kabuğuna bir tavada düzenleyin
    6. 1.6. 1. adıma dönün.
Şimdi bir döngü içinde bir döngümüz var. Bu tür yapılar çok yaygındır. Son bir örnek olarak ilkokulda sevmeyi öğrendiğimiz çarpım tablosundan bir tane yapalım.

 public static void main(String[] args) {
    // Print the second factors in a row
    System.out.println("    2  3  4  5  6  7  8  9"); 
    int i = 2;  // Assign the first factor to the variable
    while (i < 10) {  // First loop: execute as long as the first factor is less than 10
        System.out.print(i + " | ");  // Print the first factor at the beginning of the line
        int j = 2;  // The starting value of the second factor
        while (j < 10) { // Second loop: execute as long as the second factor is less than 10
            int product = i * j;  // Calculate the product of the factors
            if (product < 10)  // If the product is a single digit, then we print two spaces after the product
                System.out.print(product + "  ");
            else  // Otherwise, print the product and one space after it
                System.out.print(product + " ");
            j++;  // Increment the second factor by one
        }  // Go to the beginning of the second loop, i.e. "while (j < 10)"
        System.out.println();  // Move to the next line on the console
        i++;  // Increment the first factor by one
    } // Go to the beginning of the first loop, i.e. "while (i < 10)"
}
Konsol çıktısı:

    2  3  4  5  6  7  8  9
2 | 4 6 8 10 12 14 16 18
3 | 6 9 12 15 18 21 24 27
4 | 8 12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81
Process finished with exit code 0
Döngüler (özellikle while ifadesi), yazılımın temel yapı taşlarından biridir. CodeGym'de görevleri çözerek, tüm farklı döngü türlerini öğrenecek, inceliklerini anlayacak ve bunları kullanma konusunda pratik beceriler kazanacaksınız.
Yorumlar
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION