JavaRush /Java Blog /Random-IT /Mentre il ciclo in Java

Livello 41

28 febbraio 2021
44 views
0 comments

Mentre il ciclo in Java

introduzione

I nostri primissimi programmi erano una sequenza di istruzioni eseguite una dopo l'altra. Niente forchette. Questo è HelloWorld, che invia alla console una frase di saluto e calcoli aritmetici. Dopo i primi programmi abbiamo imparato a ramificarci, ovvero il programma eseguiva determinate azioni a seconda delle condizioni. Ecco come potresti codificare il condizionatore d'aria per accenderlo per il riscaldamento e il raffreddamento:

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

Facciamo il passo successivo. Nella vita di tutti i giorni, spesso eseguiamo azioni monotone e ripetitive, ad esempio sbucciare le mele per una torta. Questo affascinante processo può essere descritto come:

Se nella vasca sono presenti delle mele, seguire i passaggi da 1.1 a 1.4:
1. 1.1. Prendi una mela
2. 1.2. Pulitelo e tagliatelo a fette
3. 1.3. Disporre sulla base della torta di pasta frolla in una padella
4. 1.4. Torniamo al passaggio 1.

Diciamo che hai 10 mele, 2 mani e un coltello. Nella vita, pulisci costantemente tutti e dieci, guidato dallo stesso algoritmo. Come puoi fare in modo che il programma esegua un'azione ripetitiva con ciascuna mela?

Leghiamoci al numero di mele, ma se ne avessimo poche, alcuni comandi verrebbero eseguiti invano senza “carico utile” (e, magari, ci taglieremmo sbucciando una mela inesistente).
Se ci fossero più mele dei nostri team di lavorazione, alcuni prodotti rimarrebbero non trasformati.
Tale “codice” è difficile da leggere, contiene molte ripetizioni ed è difficile da modificare.

I cicli sono operatori per eseguire azioni più volte.

Il ciclo while Java (loop vile) funziona bene nel nostro caso. Questo design organizza molteplici azioni in una struttura concisa e comprensibile. Un algoritmo while per affettare le mele per una torta in Java potrebbe assomigliare a questo:

while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
}
System.out.println('Apples for the pie are processed.');

Sintassi dei comandi

Il primo modo per descrivere l'istruzione while è il seguente:

while(Логическое выражение) {
	// Loop body - periodically executed statement(s)
}

Questo viene fatto come segue (passo dopo passo):

Valutiamo la condizione booleana che segue il while tra parentesi.
Se la condizione logica è vera, vengono eseguite le istruzioni nel corpo del ciclo, dopo aver eseguito l'ultima istruzione nel corpo del ciclo, andare al passaggio 1
Se la condizione logica è falsa, vai alla prima istruzione fuori dal ciclo while.

Ciclo con precondizione

Dato che prima di eseguire il corpo del ciclo precalcoliamo sempre un'espressione logica (la condizione per entrare nel ciclo), questo tipo di while viene spesso chiamato ciclo con precondizione. Costruiamo una tabella con le prime dieci potenze intere positive di un numero:

public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(power <= 10) { // loop entry condition
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
    }
}

Risultato dell'output della console:

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

Ciclo con postcondizione

Secondo tipo di ciclo:

do {
    // Loop body - periodically executed statement(s)
}while (Логическое выражение);

Eseguito come segue (passaggi):

Viene eseguito il corpo del ciclo (immediatamente dopo la parola chiave do).
Valutiamo la condizione booleana che segue il while tra parentesi.
Se la condizione logica è vera, vai al passaggio 1
Se la condizione logica è falsa, vai alla prima istruzione fuori dal ciclo while.

Due differenze principali rispetto al tipo di ciclo precedente: il corpo del ciclo viene eseguito almeno una volta e la condizione logica viene verificata dopo l'esecuzione del corpo del ciclo. Pertanto, questo tipo di ciclo while è chiamato ciclo postcondizione. Questa volta mostreremo una tabella delle potenze di un numero non superiore a 10000:

public static void main(String[] args) {
    int number = 3;// Number to be raised to a power
    int result = number;// Result of exponentiation
    int power = 1;// Initial exponent
    do {
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        result = result * number;
    }while (result < 10000); // loop exit condition

Risultato dell'output della console:

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

Presta attenzione ai cambiamenti nel codice, confrontandolo con la versione del ciclo con una precondizione.

Fatti interessanti sul lavoro con i loop

Comandi di controllo nel corpo del ciclo

Ci sono due comandi che influenzano l'andamento del ciclo: break, di cui mostreremo le caratteristiche nel prossimo capitolo, e Continua.

continue – interrompe l'esecuzione del corpo del ciclo corrente e passa all'espressione logica dell'operatore while. Se l'espressione calcolata è vera, l'esecuzione del ciclo continuerà.
break – interrompe immediatamente l'esecuzione del ciclo corrente e salta al primo comando esterno ad esso. Pertanto, l'esecuzione del ciclo corrente viene interrotta. Lo vedremo più in dettaglio nel prossimo argomento.

Ricordiamo il nostro esempio della frutta. Se non siamo sicuri della qualità delle mele offerte, potremmo modificare il codice utilizzando il comando continue:

while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
    if (яблоко.плохое()) {  // method will return true for rotten, etc. apples
        яблоко.выкинутьВМусор();
        continue; // continue the loop, go to the condition number ofApplesIn the Basin>0
    }
    положитьВПирог(яблоко.чистить().нарезать());
}

La costruzione continueviene spesso utilizzata quando nel corpo di un loop è necessario eseguire comandi quando si verifica una determinata condizione, ad esempio, per eseguire azioni quando viene attivato un sensore nell'apparecchiatura (altrimenti continuare semplicemente il ciclo di lettura dei suoi indicatori) o per calcolare un'espressione solo in determinati passaggi del ciclo. Un esempio per l'ultimo caso è il calcolo in un ciclo while della somma di cubi di numeri naturali il cui quadrato è minore del loro numero:

public static void main(String[] args) {
    int sum = 0;    // total amount
    int i = 0;      // starting number of the row
    int count = 20; // amount of numbers
    while(i<=count) {
        i++;        // take the next number, i++ is equivalent to i=i+1
        if (i*i<=count)  // if the square of the number is less
            continue;   // number of numbers - do not count the sum
                        // move on to the next number in the loop
        sum += i*i*i; // otherwise, we calculate the sum of cubes of numbers
    } // sum += i*i*i - notation similar to sum = sum + i*i*i
    System.out.println(sum);// print result
}

Ciclo infinito

Данные управляющие команды чаще всего находят применение в бесконечном цикле. Его так называют, потому что логическое condition выхода никогда не выполняется. В codeе он выглядит примерно How:

while(true) {
    // Loop body
}

В этом случае и пригодится применение команды break для организации выхода из него. Этот вид цикла имеет место при ожидании внешних условий, которые формируются за пределами логики тела цикла. Например, в играх, эмулирующих виртуальный мир вокруг героя (выход из цикла = выход из игры), операционных системах. Или при использовании алгоритмов, возможно, улучшающих результат с каждым последующим вызовом в цикле, но ограничивая их по времени or наступлению внешнего события (шашки, шахматы or предсказание погоды). Следует помнить, что в обычных условиях бесконечные циклы – одна из проблем неустойчивости программы. Для демонстрации вернёмся к степеням числа:

public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(true) {
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        if (power>10)
            break; // exit from the loop
    }
}

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

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

Вложенные циклы

Вот мы и подошли к завершающей теме о наших циклах. Вспомним о яблочном пироге (надеюсь, вы не голодны в данный момент) и наш «цикл»:

Если в тазике есть яблоки, выполняем шаги с 1.1 по 1.4:
1. 1.1. Берем яблоко
2. 1.2. Чистим и нарезаем его дольками
3. 1.3. Помещаем на основание пирога из теста на сковороде
4. 1.4. Возвращаемся на шаг 1.

Подробнее распишем процесс нарезания дольками:

Число долек = 0
Пока число долек < 12, выполнить шаги с 2.1 по 2.3
1. 2.1. Отрезать очередную дольку от яблока
2. 2.2. Кол-во долек ++
3. 2.3. Возвращаемся на шаг 2

И вставим в наш кондитерский алгоритм:

Если в тазике есть яблоки, то выполняем шаги с 1.1 по 1.6:
1. 1.1. Берем яблоко
2. 1.2. Очищаем его от кожуры
3. 1.3. Число долек = 0
4. 1.4. Пока число долек < 12, выполнить шаги с 1.4.1 по 1.4.3
5. 1.5. Помещаем дольки на тестовое основание пирога из теста на сковороде
6. 1.6. Возвращаемся на шаг 1.

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

public static void main(String[] args) {
    // Display the values of the second multiplier in the line
    System.out.println("    2  3  4  5  6  7  8  9");
    int i = 2;      // first multiplier, assign starting value
    while(i<10) {   // First loop, execute while the first multiplier is less than 10
        System.out.print(i + " | ");// Display the first multiplier at the beginning of the string
        int j = 2;                  // second multiplier, starting value
        while (j<10) { // Second loop, execute while the second multiplier is less than 10
            int mul=i*j; // Calculate the product of factors
            if (mul<10)  // If it contains one digit, print two spaces after it
                System.out.print(mul + "  ");
            else   // otherwise output the product and after it - one space
                System.out.print(mul + " ");
            j++;     // Increase the second multiplier by one,
        }            // Go to the beginning of the second loop (while (j<10 ).... )
        System.out.println(); // Move to the next line of output
        i++;                  // Increase the first multiplier by one,
    }                         // Go to the beginning of the first loop (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, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.

Commenti

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