JavaRush /Blogue Java /Random-PT /Enquanto Loop em Java

Nível 41

28 fevereiro 2021
46 views
0 comments

Enquanto Loop em Java

Introdução

Nossos primeiros programas eram uma sequência de instruções executadas uma após a outra. Sem garfos. Este é o HelloWorld, que envia uma frase de saudação e cálculos aritméticos para o console. Após os primeiros programas, aprendemos a ramificar, ou seja, o programa realizava determinadas ações dependendo das condições. Veja como você pode codificar o ar condicionado para ligar para aquecimento e resfriamento:

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

Vamos dar o próximo passo. Na vida cotidiana, muitas vezes realizamos ações monótonas e repetitivas, por exemplo, descascar maçãs para fazer uma torta. Este processo fascinante pode ser descrito como:

Se houver maçãs na bacia, siga as etapas 1.1 a 1.4:
1. 1.1. Pegue uma maçã
2. 1.2. Limpe e corte em fatias
3. 1.3. Coloque na base da torta em uma frigideira
4. 1.4. Vamos voltar ao passo 1.

Digamos que você tenha 10 maçãs, 2 mãos e uma faca. Na vida, você limpa consistentemente todos os dez, guiado pelo mesmo algoritmo. Como você pode fazer com que o programa execute uma ação repetida com cada maçã?

Vamos nos vincular ao número de maçãs, mas se tivermos poucas delas, alguns dos comandos seriam executados em vão sem uma “carga útil” (e, talvez, nos cortaríamos ao descascar uma maçã inexistente).
Se houver mais maçãs do que as nossas equipas de processamento, alguns dos produtos não serão processados.
Esse “código” é difícil de ler, contém muitas repetições e é difícil de modificar.

Loops são operadores para executar ações múltiplas vezes.

O loop while Java (loop vil) funciona bem em nosso caso. Este design organiza múltiplas ações em uma estrutura concisa e compreensível. Um algoritmo while para fatiar maçãs para fazer uma torta em Java pode ser assim:

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

Sintaxe de comando

A primeira maneira de descrever a instrução while é a seguinte:

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

Isso é feito da seguinte maneira (passo a passo):

Avaliamos a condição booleana que segue o while entre parênteses.
Se a condição lógica for verdadeira, então os operadores no corpo do loop são executados, após executar o último operador no corpo do loop, vá para a etapa 1
Se a condição lógica for falsa, passamos para a primeira instrução fora do loop while.

Loop com pré-condição

Como antes de executar o corpo do loop, sempre pré-calculamos uma expressão lógica (a condição para entrar no loop), esse tipo de while costuma ser chamado de loop com uma pré-condição. Vamos construir uma tabela dos dez primeiros inteiros, potências positivas de um número:

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++;
    }
}

Resultado de saída do 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

Loop com pós-condição

Segundo tipo de ciclo:

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

Realizado da seguinte forma (etapas):

O corpo do loop é executado (imediatamente após a palavra-chave do).
Avaliamos a condição booleana que segue o while entre parênteses.
Se a condição lógica for verdadeira, vá para a etapa 1
Se a condição lógica for falsa, passamos para a primeira instrução fora do loop while.

Duas diferenças principais em relação ao tipo de loop anterior: o corpo do loop é executado pelo menos uma vez e a condição lógica é verificada após a execução do corpo do loop. Portanto, esse tipo de loop while é chamado de loop de pós-condição. Desta vez exibiremos uma tabela de potências de um número não superior a 10.000:

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

Resultado de saída do 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

Preste atenção nas alterações no código, comparando-o com a versão do loop com pré-condição.

Fatos interessantes sobre como trabalhar com loops

Comandos de controle no corpo do loop

Existem dois comandos que afetam o progresso do loop: break, cujos recursos mostraremos no próximo capítulo, e continuar.

continue – interrompe a execução do corpo do loop atual e passa para a expressão lógica do operador while. Se a expressão calculada for verdadeira, a execução do loop continuará.
break – interrompe imediatamente a execução do loop atual e salta para o primeiro comando fora dele. Assim, a execução do loop de corrente é interrompida. Veremos isso com mais detalhes no próximo tópico.

Vamos lembrar nosso exemplo da fruta. Se não tivermos certeza da qualidade das maçãs oferecidas, podemos alterar o código usando o 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
    }
    положитьВПирог(яблоко.чистить().нарезать());
}

A construção continueé frequentemente utilizada quando no corpo de um loop é necessário executar comandos quando ocorre determinada condição, por exemplo, para realizar ações quando um sensor do equipamento é acionado (caso contrário basta continuar o ciclo de leitura de seus indicadores) ou calcular uma expressão apenas em determinadas etapas do ciclo. Um exemplo para o último caso é o cálculo em um loop while da soma dos cubos de números naturais cujo quadrado é menor que seu número:

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 sem fim

Esses comandos de controle são usados com mais frequência em um loop infinito. É chamado assim porque a condição de saída lógica nunca é satisfeita. No código é algo como:

while(true) {
    // Loop body
}

Nesse caso, será útil usar um comando breakpara organizar uma saída dele . Este tipo de loop ocorre ao aguardar condições externas formadas fora da lógica do corpo do loop. Por exemplo, em jogos que emulam o mundo virtual ao redor do herói (sair do loop = sair do jogo), sistemas operacionais. Ou ao usar algoritmos, talvez melhorando o resultado a cada chamada subsequente no loop, mas limitando-os pelo tempo ou pela ocorrência de um evento externo (damas, xadrez ou previsão do tempo). Deve-se lembrar que em condições normais, os loops infinitos são um dos problemas de instabilidade do programa. Para demonstrar, vamos voltar às potências dos números:

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
    }
}

Resultado de saída do 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

Loops aninhados

Aqui chegamos ao tópico final sobre nossos ciclos. Vamos pensar na torta de maçã (espero que você não esteja com fome no momento) e no nosso “loop”:

Se houver maçãs na bacia, siga os passos 1.1 a 1.4:
1. 1.1. Pegue uma maçã
2. 1.2. Limpe e corte em fatias
3. 1.3. Coloque na base da torta em uma frigideira
4. 1.4. Vamos voltar ao passo 1.

Vamos descrever o processo de corte em fatias com mais detalhes:

Número de fatias = 0
Embora o número de fatias seja <12, siga as etapas 2.1 a 2.3
1. 2.1. Corte outra fatia de uma maçã
2. 2.2. Número de fatias ++
3. 2.3. Voltar para a etapa 2

E insira-o em nosso algoritmo de confeitaria:

Se houver maçãs na bacia, siga as etapas 1.1 a 1.6:
1. 1.1. Pegue uma maçã
2. 1.2. Retire-o
3. 1.3. Número de fatias = 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, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.

Comentários

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