Nuestros primeros programas eran una secuencia de instrucciones que se ejecutaban una tras otra. Sin tenedores. Esto incluye HelloWorld, que muestra un saludo. Incluye cálculos aritméticos. Después de nuestros primeros programas, aprendimos cómo bifurcar, es decir, cómo hacer que un programa realice diferentes acciones dependiendo de condiciones específicas. Aquí hay un código para controlar un sistema central de calefacción y aire acondicionado:
if (tempRoom>tempComfort)
airConditionerOn();
if (tempRoom<tempComfort)
heaterOn();
Da el siguiente paso. En la vida cotidiana, a menudo realizamos acciones repetitivas uniformes, por ejemplo, pelar manzanas para hacer un pastel. Este fascinante proceso se puede describir como:
Si hay manzanas en el tazón, ejecutamos los pasos 1.1 a 1.4:
1.1. toma una manzana
1.2. Pelarlo y cortarlo en rodajas
1.3. Coloque las rodajas de manzana en la masa de pastel en una sartén.
1.4. Regrese al paso 1.
Digamos que tienes diez manzanas, dos manos y un cuchillo. En la vida real, pelas secuencialmente la docena completa, siguiendo el mismo algoritmo para cada manzana. Pero, ¿cómo hacemos que un programa realice una acción repetitiva para cada manzana?
Nos limitamos a la cantidad de manzanas, pero si no tenemos suficientes, algunos de los comandos se ejecutarán sin una "carga útil" (y podríamos cortarnos al tratar de pelar una manzana inexistente).
Si hay más manzanas que comandos para pelar, algunas de las manzanas se quedarán sin pelar.
Tal código es difícil de leer. Tiene muchas repeticiones y es difícil de modificar.
Los bucles son declaraciones que permiten que las acciones se realicen repetidamente.
El ciclo while de Java funcionará bien en nuestro caso. Esta construcción pone múltiples acciones en una estructura concisa y comprensible. Usando un bucle while , un algoritmo de corte de manzana para un pastel podría verse así en Java:
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.");
Sintaxis de comandos
La primera variante de la instrucción while es así:
while (Boolean expression) {
// Loop body — the statement(s) that are repeatedly executed
}
Aquí hay una explicación paso a paso de lo que sucede cuando se ejecuta este código:
Evaluamos la expresión booleana que se encuentra entre paréntesis después de la palabra clave while .
Si la expresión booleana se evalúa como verdadera, se ejecutan las declaraciones en el cuerpo del bucle . Después de ejecutar la última declaración en el cuerpo del ciclo, vamos al paso 1
Si la expresión booleana se evalúa como falsa, saltamos a la primera declaración después del bucle while .
Bucle con una condición previa
Debido a que siempre evaluamos la expresión booleana (la condición para ingresar al ciclo) antes de ejecutar el cuerpo del ciclo, esta forma del ciclo while a menudo se denomina ciclo con una condición previa . Construyamos una tabla de las diez primeras potencias de un número:
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++;
}
}
Salida de la consola:
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
Bucle con una condición posterior
Aquí está la segunda variante de este bucle:
do {
// Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
Aquí hay una explicación de lo que sucede cuando se ejecuta este código:
El cuerpo del bucle se ejecuta (inmediatamente después de la palabra clave do ).
Evaluamos la expresión booleana que se encuentra entre paréntesis después de la palabra clave while .
Si la expresión booleana se evalúa como verdadera, vamos al paso 1
Si la expresión booleana se evalúa como falsa, saltamos a la primera declaración después del bucle while .
Las dos diferencias principales con el bucle anterior son: 1) el cuerpo del bucle se ejecuta al menos una vez y 2) la expresión booleana se evalúa después de ejecutar el cuerpo del bucle. En consecuencia, este tipo de bucle while se denomina bucle con una condición posterior . En esta ocasión mostraremos una tabla de potencias de un número que no supere 10000:
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
}
Salida de la consola:
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
Presta atención a los cambios en el código. Compare esto con el bucle con una condición previa.
Datos interesantes sobre el trabajo con bucles
Sentencias de bifurcación dentro del cuerpo del ciclo
Hay dos declaraciones que afectan la ejecución dentro de un ciclo: break (que discutiremos con más detalle en el próximo capítulo) y
continuar.
continuar: salta la ejecución del resto del cuerpo del ciclo en la iteración actual y salta a la evaluación de la expresión booleana de la instrucción while. Si la expresión se evalúa como verdadera, entonces el bucle continúa.
break: finaliza inmediatamente la ejecución de la iteración actual y transfiere el control a la primera declaración después del bucle. Por lo tanto, esta instrucción finaliza la ejecución del ciclo actual. Lo consideraremos con más detalle en el próximo artículo.
Recuerde nuestro ejemplo de la fruta. Si no estamos seguros de la calidad de las manzanas, podemos cambiar el código usando una declaración
de continuación :
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());
}
La declaración
de continuación se usa a menudo cuando las declaraciones en el cuerpo del ciclo deben ejecutarse si se cumple una determinada condición. Por ejemplo, podemos querer realizar acciones cuando se activa un sensor de hardware (de lo contrario, simplemente continuar el ciclo en el que tomamos las lecturas del sensor) o podemos querer calcular una expresión solo en ciertas iteraciones de un ciclo. Un ejemplo de este último caso puede verse en nuestro uso de un ciclo while para calcular la suma de cubos de números naturales cuyo cuadrado es menor que el número de números. ¿Confundido? Mira el siguiente código:
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
}
Bucle infinito
Estas declaraciones de bifurcación se usan con mayor frecuencia en bucles infinitos. Llamamos a un ciclo infinito si la condición booleana para salir del ciclo nunca se cumple. En código, se ve algo como esto:
while (true) {
// Loop body
}
En este caso, una sentencia
break nos ayuda a salir del ciclo. Este tipo de bucle es adecuado cuando se esperan condiciones externas determinadas fuera del cuerpo del bucle. Por ejemplo, en sistemas operativos o juegos (salir del bucle significa salir del juego). O cuando se usan algoritmos que intentan, con cada iteración de un ciclo, mejorar algún resultado, pero limitan el número de iteraciones según el tiempo transcurrido o la ocurrencia de un evento externo (por ejemplo, damas, ajedrez o pronóstico del tiempo). Recuerde que, en condiciones normales, los bucles infinitos no son deseables. Para demostrarlo, volvamos a la exponenciación:
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
}
}
Salida de la consola:
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
Bucles anidados
Y ahora llegamos a nuestro tema final sobre los bucles. Recuerde ese pastel de manzana (espero que no tenga hambre en este momento) y nuestro ciclo de pelar manzanas:
Si hay manzanas en el tazón, ejecutamos los pasos 1.1 a 1.4:
1.1. toma una manzana
1.2. Pelarlo y cortarlo en rodajas
1.3. Coloque las rodajas de manzana en la masa de pastel en una sartén.
1.4. Regrese al paso 1.
Describamos el proceso de corte con más detalle:
Número de rebanadas = 0
Siempre que el número de cortes sea < 12, realice los pasos 2.1 a 2.3
2.1. Corta otra rebanada de la manzana.
2.2. Número de rebanadas++
2.3. Volver al paso 2
Y agregaremos esto a nuestro algoritmo de creación de tartas:
Si hay manzanas en el tazón, ejecutamos los pasos 1.1 a 1.6:
1.1. toma una manzana
1.2. Pelarla
1.3. Número de rebanadas = 0
1.4. Siempre que el número de cortes sea < 12, realice los pasos 1.4.1 a 1.4.3
1.4.1. Corta otra rebanada de la manzana.
1.4.2. Número de rebanadas++
1.4.3. Volver al paso 1.4
1.5. Coloque las rodajas de manzana en la masa de pastel en una sartén.
1.6. Regrese al paso 1.
Ahora tenemos un bucle dentro de un bucle. Construcciones como esta son muy comunes. Como ejemplo final, construyamos una de las tablas de multiplicar que aprendimos a amar en la escuela primaria.
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)"
}
Los bucles (en particular, la instrucción
while ) son uno de los componentes fundamentales del software. Al resolver tareas en CodeGym, aprenderá todos los diferentes tipos de bucles, comprenderá sus complejidades y adquirirá habilidades prácticas para usarlos.
Digamos que tienes diez manzanas, dos manos y un cuchillo. En la vida real, pelas secuencialmente la docena completa, siguiendo el mismo algoritmo para cada manzana. Pero, ¿cómo hacemos que un programa realice una acción repetitiva para cada manzana?
GO TO FULL VERSION