Estructuras repetitivas en Java

Los estructuras repetitivas o bucles nos sirven para repetir un bloque de código hasta que la condición no se cumpla o sea falso.

While

El bucle while validará si una condición se cumple antes de entrar al bucle, una vez finalizada las instrucciones dentro del bucle volverá a validar la condición.

Estructura de un While :

while(condición) {
  // Código a ejecutar si la condición es verdad
}

Ejemplo usando while :

/*
------------------------------------------------------------------------------------------
En este ejemplo, vamos adivinar un número del 0 al 10.
------------------------------------------------------------------------------------------
*/
// Declaramos la variale input tipo Scanner para leer datos de la consola
Scanner input = new Scanner(System.in);
// Leemos dato de consola
System.out.print("Adivina el número del 0 al 10 : ");
int number = input.nextInt();
// Generamos un número random de 0 al 10
int random = (int)(Math.random() * 10);
// Validamos si el valor ingresado es diferente al número random
while (number != random) {
  // Si se cumple la condición, volvemos a leer dato de consola
  System.out.print("Fallaste, Intenta nuevamente : ");
  number = input.nextInt();
}
// Si la condición no se cumple, continuará ejecutando lo siguiente
System.out.println("Lo lograste!");

Do - While

El código incluido en el bucle Do - While se ejecutará si o si la primera vez, luego validará si la condición, de ser verdad repetirá las instrucciones dentro del bucle.

Estructura de un Do-While :

do {
  // Código a ejecutar si o si la primera vez, luego sólo se ejecuta si la condición es verdad
}while(condición);

Como podemos observar en el ejemplo anterior con el bucle While, si el valor del número random es 0 no ejecutaría las instrucciones ya que la condición sería falsa. Sin embargo, con la estructura Do While garantizamos que se ejecute al menos 1 vez y así solicitar dentro del bucle el número al usuario.

Ejemplo usando do-while:

/*
------------------------------------------------------------------------------------------
En este ejemplo, vamos adivinar un número del 0 al 10.
------------------------------------------------------------------------------------------
*/
// Declaramos la variale input tipo Scanner para leer datos de la consola
Scanner input = new Scanner(System.in);
int number;
// Generamos un número random de 0 al 10
int random = (int)(Math.random() * 10);
do {
  // Leemos dato de consola
  System.out.print("Adivina el número del 0 al 10 : ");
  number = input.nextInt();
  // Validamos si el valor ingresado es diferente al número random
} while (number != random);
// Si la condición no se cumple, continuará ejecutando lo siguiente
System.out.println("Lo lograste!");

For

Esta estructura repetitiva se suele utilizar cuando se conoce la cantidad de repeticiones a realizar. Este bucle recibe 3 sentencias, la inicialización del contador, una condición y la operación para aumentar o disminuir el contador.

Estructura de un For :

for(inicialización del bucle; condición; incremento o decremento) {
  // Código a ejecutar mientras la condición se cumpla
}

Ahora veremos un ejemplo, iterando los elementos de un array, donde validaremos que el contador sea menor al tamaño del array usando su método length. Para saber más de arreglos puedes visitar el artículo de Arrays en Java del blog.

/*
------------------------------------------------------------------------------------------
En este ejemplo, vamos a iterar un array usando for.
------------------------------------------------------------------------------------------
*/
String dias[] = {"Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"};
for (int i = 0; i < dias.length; i++) {
  System.out.print(dias[i] + " ");
}

ForEach

Este bucle nos permite iterar los elementos de un array. Si bien las estructuras repetitivas anteriores cuentan con una condicional para salir del bucle, un forEach finalizará el bucle cuando recorra cada uno de los elementos del array; es decir, si el arreglo tiene 4 elementos, se repetirá 4 veces.

Estructura de un ForEach :

for((tipo de dato) elemento : array) {
  // Código a ejecutar mientras hayan elementos en el array
}

Ejemplo usando forEach :

/*
------------------------------------------------------------------------------------------
En este ejemplo, vamos a iterar un array usando forEach.
------------------------------------------------------------------------------------------
*/
String dias[] = {"Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"};
for (String dia : dias) {
  System.out.print(dia + " ");
}

Espero que este artículo te haya sido útil, de ser así compártelo para que más personas puedan conocer sobre las estructuras repetitivas en Java.

¡Happy Coding! 😉