JavaRush /Blog Java /Random-ES /Mientras bucle en Java

Nivel 41

28 febrero 2021
47 views
0 comments

Mientras bucle en Java

Introducción

Nuestros primeros programas eran una secuencia de instrucciones que se ejecutaban una tras otra. Sin tenedores. Este es HelloWorld, que envía una frase de saludo y cálculos aritméticos a la consola. Después de los primeros programas, aprendimos a bifurcar, es decir, el programa realizaba determinadas acciones dependiendo de las condiciones. Así es como podría codificar el aire acondicionado para que se encienda para calentar y enfriar:

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

Demos el siguiente paso. En la vida cotidiana, a menudo realizamos acciones monótonas y repetitivas, por ejemplo, pelar manzanas para hacer un pastel. Este fascinante proceso se puede describir como:

Si hay manzanas en el recipiente, siga los pasos 1.1 a 1.4:
1. 1.1. toma una manzana
2. 1.2. Límpialo y córtalo en rodajas.
3. 1.3. Colocar sobre la base de la tarta de hojaldre en una sartén
4. 1.4. Volvamos al paso 1.

Digamos que tienes 10 manzanas, 2 manos y un cuchillo. En la vida, limpias constantemente los diez, guiado por el mismo algoritmo. ¿Cómo puedes hacer que el programa realice una acción repetitiva con cada manzana?

Limitémonos al número de manzanas, pero si tenemos pocas, algunos de los comandos se ejecutarían en vano sin una “carga útil” (y, tal vez, nos cortaríamos mientras pelamos una manzana inexistente).
Si hay más manzanas que nuestros equipos de procesamiento, algunos de los productos quedarían sin procesar.
Este “código” es difícil de leer, contiene muchas repeticiones y es difícil de modificar.

Los bucles son operadores para realizar acciones varias veces.

El bucle while de Java (bucle vil) funciona bien en nuestro caso. Este diseño organiza múltiples acciones en una estructura concisa y comprensible. Un algoritmo while para cortar manzanas para hacer un pastel en Java podría verse así:

while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- esto es un decremento, reduce el número de manzanas en una
}
System.out.println('Las manzanas para el pastel se procesan.');

Sintaxis del comando

La primera forma de describir la declaración while es la siguiente:

while(Логическое выражение) {
	// Cuerpo del bucle: declaración(es) ejecutada(s) periódicamente
}

Esto se hace de la siguiente manera (paso a paso):

Evaluamos la condición booleana que sigue al while entre paréntesis.
Si la condición lógica es verdadera, entonces se ejecutan las declaraciones en el cuerpo del bucle, después de ejecutar la última declaración en el cuerpo del bucle, vaya al paso 1
Si la condición lógica es falsa, vaya a la primera declaración fuera del ciclo while.

Bucle con condición previa

Dado que antes de ejecutar el cuerpo del bucle, siempre calculamos previamente una expresión lógica (la condición para ingresar al bucle), este tipo de while a menudo se denomina bucle con una condición previa. Construyamos una tabla de las primeras diez potencias positivas enteras de un número:

public static void main(String[] args) {
    int number = 3; // Número a elevar a una potencia
    int result = 1; // Resultado de la exponenciación
    int power = 1; // exponente inicial
    while(power <= 10) { // condición de entrada al bucle
        result = result * number;
        System.out.println(number + "en la medida" + power + " = " + result);
        power++;
    }
}

Resultado de salida de la consola:

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

Bucle con poscondición

Segundo tipo de ciclo:

do {
    // Cuerpo del bucle: declaración(es) ejecutada(s) periódicamente
}while (Логическое выражение);

Realizado de la siguiente manera (pasos):

Se ejecuta el cuerpo del bucle (inmediatamente después de la palabra clave do).
Evaluamos la condición booleana que sigue al while entre paréntesis.
Si la condición lógica es verdadera, vaya al paso 1.
Si la condición lógica es falsa, vaya a la primera declaración fuera del ciclo while.

Dos diferencias principales con respecto al tipo de bucle anterior: el cuerpo del bucle se ejecuta al menos una vez y la condición lógica se verifica después de ejecutar el cuerpo del bucle. Por lo tanto, este tipo de bucle while se denomina bucle de poscondición. En esta ocasión mostraremos una tabla de potencias de un número no mayor a 10000:

public static void main(String[] args) {
    int number = 3;// Número a elevar a una potencia
    int result = number;// Resultado de la exponenciación
    int power = 1;// exponente inicial
    do {
        System.out.println(number + "en la medida" + power + " = " + result);
        power++;
        result = result * number;
    }while (result < 10000); // condición de salida del bucle

Resultado de salida de la consola:

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 atención a los cambios en el código, comparándolo con la versión del bucle con una condición previa.

Datos interesantes sobre trabajar con bucles.

Comandos de control en el cuerpo del bucle.

Hay dos comandos que afectan el progreso del bucle: break, cuyas características mostraremos en el próximo capítulo, y continuar.

continuar : detiene la ejecución del cuerpo del bucle actual y pasa a la expresión lógica del operador while. Si la expresión calculada es verdadera, la ejecución del bucle continuará.
break : detiene inmediatamente la ejecución del bucle actual y salta al primer comando fuera de él. Por tanto, se interrumpe la ejecución del bucle actual. Lo veremos con más detalle en el siguiente tema.

Recordemos nuestro ejemplo de frutas. Si no estamos seguros de la calidad de las manzanas ofrecidas, podríamos cambiar el código usando el comando continue:

while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    числоЯблокВТазике--;//-- esto es un decremento, reduce el número de manzanas en una
    if (яблоко.плохое()) {  // el método devolverá verdadero para podrido, etc. manzanas
        яблоко.выкинутьВМусор();
        continue; // continúa el bucle, ve al número de condición de manzanas en la cuenca> 0
    }
    положитьВПирог(яблоко.чистить().нарезать());
}

La construcción continuese usa a menudo cuando en el cuerpo de un bucle es necesario ejecutar comandos cuando ocurre una determinada condición, por ejemplo, realizar acciones cuando se activa un sensor en el equipo (de lo contrario, simplemente continúe el ciclo de lectura de sus indicadores) o calcular una expresión sólo en ciertos pasos del ciclo. Un ejemplo para el último caso es el cálculo en un bucle while de la suma de cubos de números naturales cuyo cuadrado es menor que su número:

public static void main(String[] args) {
    int sum = 0;    // cantidad total
    int i = 0;      // número inicial de la fila
    int count = 20; // cantidad de numeros
    while(i<=count) {
        i++;        // toma el siguiente número, i++ es equivalente a i=i+1
        if (i*i<=count)  //si el cuadrado del numero es menor
            continue;   // número de números - no cuente la suma
                        // pasar al siguiente número en el ciclo
        sum += i*i*i; // de lo contrario, calculamos la suma de cubos de números
    } // sum += i*i*i - notación similar a sum = sum + i*i*i
    System.out.println(sum);// imprimir resultado
}

ciclo sin fin

Данные управляющие команды чаще всего находят применение в бесконечном цикле. Его так называют, потому что логическое condición выхода никогда не выполняется. В códigoе он выглядит примерно Cómo:

while(true) {
    // cuerpo del bucle
}

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

public static void main(String[] args) {
    int number = 3; // Número a elevar a una potencia
    int result = 1; // Resultado de la exponenciación
    int power = 1; // exponente inicial
    while(true) {
        result = result * number;
        System.out.println(number + "en la medida" + power + " = " + result);
        power++;
        if (power>10)
            break; // salir del bucle
    }
}

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

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.

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

public static void main(String[] args) {
    // Mostrar los valores del segundo multiplicador en la línea
    System.out.println("    2  3  4  5  6  7  8  9");
    int i = 2;      // primer multiplicador, asignar valor inicial
    while(i<10) {   // Primer bucle, ejecutar mientras el primer multiplicador es menor que 10
        System.out.print(i + " | ");// Mostrar el primer multiplicador al principio de la cadena
        int j = 2;                  // segundo multiplicador, valor inicial
        while (j<10) { // Segundo bucle, ejecutar mientras el segundo multiplicador es menor que 10
            int mul=i*j; // Calcular el producto de factores
            if (mul<10)  // Si contiene un dígito, imprime dos espacios después
                System.out.print(mul + "  ");
            else   // de lo contrario, mostrar el producto y después de él: un espacio
                System.out.print(mul + " ");
            j++;     // Incrementa el segundo multiplicador por uno,
        }            // Ir al principio del segundo ciclo (while (j<10 ).... )
        System.out.println(); // Mover a la siguiente línea de salida
        i++;                  // Incrementa el primer multiplicador por uno,
    }                         // Ir al principio del primer bucle (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, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.

Comentarios

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