JavaRush /Blog Java /Random-PL /Podczas gdy pętla w Javie

Poziom 41

28 lutego 2021
48 views
0 comments

Podczas gdy pętla w Javie

Wstęp

Nasze pierwsze programy były sekwencją instrukcji wykonywanych jedna po drugiej. Żadnych widelców. To jest HelloWorld, który wysyła do konsoli frazę powitalną i obliczenia arytmetyczne. Po pierwszych programach nauczyliśmy się rozgałęziać, czyli program wykonywał określone akcje w zależności od warunków. Oto jak można zaprogramować klimatyzator tak, aby włączał ogrzewanie i chłodzenie:

if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort
    heaterOn();

Zróbmy kolejny krok. W życiu codziennym często wykonujemy monotonne, powtarzalne czynności, np. obieramy jabłka na ciasto. Ten fascynujący proces można opisać następująco:

Jeśli w misce znajdują się jabłka, wykonaj kroki od 1.1 do 1.4:
1. 1.1. Weź jabłko
2. 1.2. Oczyścić i pokroić w plasterki
3. 1.3. Ułożyć na dnie ciasta na patelni
4. 1.4. Wróćmy do kroku 1.

Załóżmy, że masz 10 jabłek, 2 ręce i jeden nóż. W życiu konsekwentnie sprzątasz całą dziesiątkę, kierując się tym samym algorytmem. Jak sprawić, aby program wykonywał powtarzającą się akcję z każdym jabłkiem?

Przywiążmy się do ilości jabłek, ale gdybyśmy mieli ich niewiele, to część poleceń bez „ładuneku” zostałaby wykonana na próżno (a być może skaleczylibyśmy się przy obieraniu nieistniejącego jabłka).
Jeśli jabłek będzie więcej niż naszych zespołów zajmujących się przetwórstwem, część produktów pozostanie nieprzetworzona.
Taki „kod” jest trudny do odczytania, zawiera dużo powtórzeń i jest trudny do modyfikacji.

Pętle to operatory umożliwiające wielokrotne wykonywanie akcji.

Pętla while Java (podła pętla) działa dobrze w naszym przypadku. Ten projekt organizuje wiele działań w zwięzłą i zrozumiałą strukturę. Algorytm krojenia jabłek na ciasto w Javie może wyglądać następująco:

while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- to jest ubytek, zmniejsza liczbę jabłek o jeden
}
System.out.println(„Jabłka na ciasto są przetwarzane”.);

Składnia poleceń

Pierwszy sposób opisania instrukcji while wygląda następująco:

while(Логическое выражение) {
	// Treść pętli - okresowo wykonywane instrukcje
}

Odbywa się to w następujący sposób (krok po kroku):

Oceniamy warunek boolowski, który następuje po znaku while w nawiasach.
Jeżeli warunek logiczny jest spełniony to wykonywane są instrukcje z treści pętli, po wykonaniu ostatniej instrukcji z treści pętli przejdź do kroku 1
Jeśli warunek logiczny jest fałszywy, to przechodzimy do pierwszej instrukcji poza pętlą while.

Pętla z warunkiem wstępnym

Ponieważ przed wykonaniem ciała pętli zawsze wstępnie obliczamy wyrażenie logiczne (warunek wejścia do pętli), ten typ while często nazywany jest pętlą z warunkiem wstępnym. Zbudujmy tabelę pierwszych dziesięciu liczb całkowitych, dodatnich potęg liczby:

public static void main(String[] args) {
    int number = 3; // Liczba, która ma zostać podniesiona do potęgi
    int result = 1; // Wynik potęgowania
    int power = 1; // Początkowy wykładnik
    while(power <= 10) { // warunek wejścia do pętli
        result = result * number;
        System.out.println(number + "w stopniu" + power + " = " + result);
        power++;
    }
}

Wynik wyjściowy konsoli:

3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

Pętla z warunkiem końcowym

Drugi typ cyklu:

do {
    // Treść pętli - okresowo wykonywane instrukcje
}while (Логическое выражение);

Wykonano w następujący sposób (kroki):

Wykonywane jest ciało pętli (bezpośrednio po słowie kluczowym do).
Oceniamy warunek boolowski, który następuje po znaku while w nawiasach.
Jeśli warunek logiczny jest prawdziwy, przejdź do kroku 1
Jeśli warunek logiczny jest fałszywy, to przechodzimy do pierwszej instrukcji poza pętlą while.

Dwie główne różnice w stosunku do poprzedniego typu pętli: treść pętli jest wykonywana co najmniej raz, a warunek logiczny jest sprawdzany po wykonaniu treści pętli. Dlatego ten typ pętli while nazywany jest pętlą warunku końcowego. Tym razem wyświetlimy tablicę potęg liczby nieprzekraczającej 10000:

public static void main(String[] args) {
    int number = 3;// Liczba, która ma zostać podniesiona do potęgi
    int result = number;// Wynik potęgowania
    int power = 1;// Początkowy wykładnik
    do {
        System.out.println(number + "w stopniu" + power + " = " + result);
        power++;
        result = result * number;
    }while (result < 10000); // warunek wyjścia z pętli

Wynik wyjściowy konsoli:

3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
Process finished with exit code 0

Zwróć uwagę na zmiany w kodzie, porównując go z wersją pętli z warunkiem wstępnym.

Interesujące fakty na temat pracy z pętlami

Polecenia sterujące w treści pętli

Na przebieg pętli wpływają dwie komendy: break, której cechy pokażemy w następnym rozdziale, oraz Kontynuować.

kontynuuj – zatrzymuje wykonywanie treści bieżącej pętli i przechodzi do logicznego wyrażenia operatora while. Jeśli obliczone wyrażenie jest prawdziwe, wykonywanie pętli będzie kontynuowane.
break – natychmiast zatrzymuje wykonywanie bieżącej pętli i przeskakuje do pierwszego polecenia spoza niej. W ten sposób przerywane jest wykonywanie pętli prądowej. Przyjrzymy się temu bardziej szczegółowo w następnym temacie.

Przypomnijmy nasz przykład z owocami. Jeśli nie jesteśmy pewni jakości oferowanych jabłek, możemy zmienić kod za pomocą polecenia continue:

while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    числоЯблокВТазике--;//-- to jest ubytek, zmniejsza liczbę jabłek o jeden
    if (яблоко.плохое()) {  // metoda zwróci true dla zgniłych itp. jabłka
        яблоко.выкинутьВМусор();
        continue; // kontynuujemy pętlę, przechodzimy do warunku numer ApplesIn the Basin>0
    }
    положитьВПирог(яблоко.чистить().нарезать());
}

Konstrukcję continueczęsto stosuje się wtedy, gdy w ciele pętli konieczne jest wykonanie poleceń po zaistnieniu określonego warunku, np. wykonanie akcji po uruchomieniu czujnika w urządzeniu (w przeciwnym razie wystarczy kontynuować cykl odczytu jego wskaźników) lub obliczyć wyrażenie tylko w niektórych etapach cyklu. Przykładem ostatniego przypadku jest obliczenie w pętli while sumy kostek liczb naturalnych, których kwadrat jest mniejszy od ich liczby:

public static void main(String[] args) {
    int sum = 0;    // całkowita kwota
    int i = 0;      // numer początkowy wiersza
    int count = 20; // ilość liczb
    while(i<=count) {
        i++;        // weź następną liczbę, i++ jest równoważne i=i+1
        if (i*i<=count)  // jeśli kwadrat liczby jest mniejszy
            continue;   // liczba liczb - nie licz sumy
                        // przejście do następnej liczby w pętli
        sum += i*i*i; // w przeciwnym razie obliczamy sumę sześcianów liczb
    } // sum += i*i*i - zapis podobny do sum = sum + i*i*i
    System.out.println(sum);//wydrukuj wynik
}

Niekończący się cykl

Te polecenia sterujące są najczęściej używane w nieskończonej pętli. Nazywa się to tym, ponieważ logiczny warunek wyjścia nigdy nie jest spełniony. W kodzie wygląda to mniej więcej tak:

while(true) {
    // Treść pętli
}

W takim przypadku przydatne będzie użycie polecenia breakw celu zorganizowania wyjścia z niego . Ten typ pętli występuje podczas oczekiwania na warunki zewnętrzne, które powstają poza logiką treści pętli. Na przykład w grach, które emulują wirtualny świat wokół bohatera (wyjście z pętli = wyjście z gry), systemy operacyjne. Lub w przypadku korzystania z algorytmów, być może poprawiając wynik z każdym kolejnym wywołaniem pętli, ale ograniczając je czasem lub wystąpieniem zdarzenia zewnętrznego (warcaby, szachy lub prognoza pogody). Należy pamiętać, że w normalnych warunkach nieskończone pętle są jednym z problemów niestabilności programu. Aby to wykazać, wróćmy do potęg liczb:

public static void main(String[] args) {
    int number = 3; // Liczba, która ma zostać podniesiona do potęgi
    int result = 1; // Wynik potęgowania
    int power = 1; // Początkowy wykładnik
    while(true) {
        result = result * number;
        System.out.println(number + "w stopniu" + power + " = " + result);
        power++;
        if (power>10)
            break; // wyjście z pętli
    }
}

Wynik wyjściowy konsoli:

3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

Pętle zagnieżdżone

Tutaj dochodzimy do ostatniego tematu dotyczącego naszych cykli. Pomyślmy o szarlotce (miejmy nadzieję, że nie jesteście w tej chwili głodni) i naszej „pętli”:

Jeśli w misce znajdują się jabłka, wykonaj kroki od 1.1 do 1.4:
1. 1.1. Weź jabłko
2. 1.2. Oczyścić i pokroić w plasterki
3. 1.3. Ułożyć na dnie ciasta na patelni
4. 1.4. Wróćmy do kroku 1.

Opiszmy bardziej szczegółowo proces krojenia w plasterki:

Liczba plasterków = 0
Gdy liczba plasterków wynosi < 12, wykonaj kroki od 2.1 do 2.3
1. 2.1. Wytnij kolejny plasterek jabłka
2. 2.2. Liczba plasterków ++
3. 2.3. Wróć do kroku 2

I wstaw to do naszego algorytmu cukierniczego:

Jeśli w misce znajdują się jabłka, wykonaj kroki od 1.1 do 1.6:
1. 1.1. Weź jabłko
2. 1.2. Odklej to
3. 1.3. Liczba plasterków = 0
4. 1.4. Пока число долек < 12, выполнить шаги с 1.4.1 по 1.4.3
5. 1.5. Помещаем дольки на тестовое основание пирога из теста на сковороде
6. 1.6. Возвращаемся на шаг 1.

ПолучLub цикл в цикле. Подобные конструкции весьма частые. Для завершающего примера построим таблицу умножения, которые школьники 90-х видели на обложках тетрадей в младших классах.

public static void main(String[] args) {
    // Wyświetl wartości drugiego mnożnika w linii
    System.out.println("    2  3  4  5  6  7  8  9");
    int i = 2;      // pierwszy mnożnik, przypisz wartość początkową
    while(i<10) {   // Pierwsza pętla, wykonaj, gdy pierwszy mnożnik jest mniejszy niż 10
        System.out.print(i + " | ");// Wyświetl pierwszy mnożnik na początku łańcucha
        int j = 2;                  // drugi mnożnik, wartość początkowa
        while (j<10) { // Druga pętla, wykonaj, gdy drugi mnożnik jest mniejszy niż 10
            int mul=i*j; // Oblicz iloczyn czynników
            if (mul<10)  // Jeśli zawiera jedną cyfrę, wypisz po niej dwie spacje
                System.out.print(mul + "  ");
            else   // w przeciwnym razie wypisz produkt, a po nim - jedną spację
                System.out.print(mul + " ");
            j++;     // Zwiększ drugi mnożnik o jeden,
        }            // Przejdź na początek drugiej pętli (while (j<10 ).... )
        System.out.println(); // Przejdź do następnej linii wyjścia
        i++;                  // Zwiększ pierwszy mnożnik o jeden,
    }                         // Przejdź na początek pierwszej pętli (while ( i<10 ) ....
}

Результат вывода на консоль:

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

Циклы (в частности, оператор while) – один из фундаментальных кирпичиков построения программ. Решая задачи на JavaRush, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.

Komentarze

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION