Instrucciones de control repetitivas en Java

Las instrucciones de control repetitivas en Java son un tipo de instrucción que permite repetir la ejecución de una o varias instrucciones sin tener que escribirlas varias veces. Generan un bucle de ejecución, por eso a este tipo de instrucciones también se las conoce como bucles.

¿Quieres saber cómo utilizar los bucles for, while y do while en Java? Pues sigue leyendo.

Esto es todo lo que vas a encontrar en este artículo:

¿Cuándo debes utilizar instrucciones repetitivas en Java?

Supongamos que tienes la siguiente instrucción en Java:

System.out.println("¡Hola mundo!");

La salida por pantalla que genera dicha instrucción es esta:

¡Hola mundo!

Hasta aquí todo bien ¿no?

Y si la salida que buscas fuese esta:

¡Hola mundo!
¡Hola mundo!
¡Hola mundo!
¡Hola mundo!
¡Hola mundo!

¿Escribirias la instrucción 5 veces?:

System.out.println("¡Hola mundo!");
System.out.println("¡Hola mundo!");
System.out.println("¡Hola mundo!");
System.out.println("¡Hola mundo!");
System.out.println("¡Hola mundo!");

Y si en vez de 5 veces quisieses que se mostrase 1000 veces, ¿La escribirías 1000 veces?

Piénsalo bien, es una locura. Tiene que existir otra forma más sencilla y, sobre todo, más automática de hacerlo.

Así es, la solución es utilizar instrucciones de control repetitivas (o instrucciones de control iterativas o bucles, llámalas como quieras).

En Java existen 3 tipos de instrucciones de control repetitivas : for, while y do while.

A continuación te las explico en detalle.

El bucle for en Java

La instrucción for es una de instrucciones repetitivas que existen en Java y se suele utilizar cuando el número de repeticiones es conocido.

Por ejemplo: mostrar una cadena 10 veces por pantalla, pedir 5 números al usuario, ejecutar una instrucción 30 veces.

Cuando conoces el número de repeticiones el bucle for es la solución más evidente. (Aunque no es la única solución).

Sintaxis de la instrucción for en Java

La sintaxis de la instrucción for en Java es la siguiente:

for (inicialicación; condición; actualización){
    //instrucciones que se repiten
}

Como puedes observar la instrucción for se compone de 3 elementos encerrados entre paréntesis y separados por punto y coma (;):

• inicialización: Aquí es donde se inicializan todas las variables que necesitará el bucle for para funcionar.
• condición: Se trata de una operación lógica, es decir, una condición que devolverá un resultado true o false tras su evaluación. En esta operación están implicadas las variables del bucle. Si la condición tiene valor true el bucle se repite, si la condición tiene valor false el bucle se para y finaliza su ejecución.
• actualización: Son instrucciones que se realizan sobre las variables del bucle. Estas instrucciones normalmente modifican el valor de dichas variables, por lo que la evaluación de la condición se verá afectada. Cada vez que se ejecuta la actualización se evalúa de nuevo la condición.

Las instrucciones que se repiten se encierran entre llaves. Eso es el cuerpo del bucle.

¿Suena complejo? No lo es tanto. Vamos a ver un ejemplo para que lo entiendas mejor.

Ejemplo del bucle for en Java

Supongamos que quieres mostrar un mensaje 5 veces por pantalla. Utilizando un bucle for es muy fácil:

for (int i=0; i<5; i++){
    System.out.println("¡Hola mundo!");
}

Como puedes ver en el ejemplo, la instrucción que se tiene que ejecutar 5 veces está encerrada entre llaves:

{
    System.out.println("¡Hola mundo!");
}

El bucle for es el responsable de conseguir que la instrucción se repita 5 veces.

Vamos a analizarlo para comprobar si es así o no y comprender cómo funciona el for en Java:

• inicialización: Se está declarando una variable i de tipo int (int i=0). También se está inicializando con valor 0.

• condición: La condición para que el bucle se repita es que i sea menor que 5 (i<5). Si el valor inicial de i es 0 la condición se cumple.
  Cada vez que se evalúa la condición y esta es true se ejecuta el cuerpo del bucle (la instrucción encerrada entre llaves).

• actualización: La operación de actualización definida es un incremento de la variable i (i++).
  Cada vez que se ejecuta la operación de actualización se vuelve a evaluar la condición. Si lo piensas de forma lógica, i se incrementa en una unidad cada vez, por tanto, en algún momento su valor alcanzará 5 y la condición (i<5) dejará de ser true. Como consecuencia el bucle se detendrá.

El bucle while en Java

El siguiente tipo de instrucción de control repetitiva en Java es el bucle while. Esta instrucción se utiliza cuándo el número de repeticiones no es conocido y está comprendido entre 0 y N.

Esto no significa que no se pueda utilizar cuando se conoce el número de repeticiones. Es igual de valido que un bucle for.

Sintaxis de la instrucción while en Java

La sintaxis de la instrucción while es la siguiente:

while (condición){
    //instrucciones que se repiten
}

Como puedes ver, la sintaxis del bucle while es más sencilla que la del bucle for. El funcionamiento también lo es.

Las instrucciones encerradas entre llaves (cuerpo del bucle) se ejecutan mientras la condición del while (encerrada entre paréntesis) sea true.

Si, estás en lo cierto, la condición es una operación lógica que devuelve un valor boolean, es decir true o false. Cuando el valor es true se ejecuta el cuerpo del bucle y se vuelve a evaluar la condición. Si sigue siendo true se repite el proceso.

¿Cuándo se detiene la ejecución de un bucle while en Java? Pues cuando la condición sea false. Si la condición siempre es true estaríamos ante un bucle infinito, por tanto, dentro del cuerpo del bucle debes implementar instrucciones que afecten de alguna forma la condición para que esta llegue a ser false en algún momento.

Vamos a ver un ejemplo para que entiendas todo esto mejor.

Ejemplo del bucle while en Java

Supón que tienes una variable entera con un valor positivo. ¿Cuántas veces tendrías que dividir entre 2 el valor de dicha variable para llegar a 0? Difícil de saber si ni siquiera conocemos el valor de la variable ¿Verdad?.

Vamos a implementar un programa que nos de la respuesta indistintamente del valor que tenga la variable inicialmente:

int num = 50;
int veces=0;

while (num>0){
    num = num / 2;
    veces++;
}

System.out.println (veces);

La salida generada por el código del ejemplo es 6, teniendo en cuenta que la variable (num) comienza con valor 50. Vamos a analizar qué ha ocurrido exactamente.

Partimos con dos variables enteras (int num = 50; int veces = 50;). La primera variable (num) es la que contiene el numero que iremos dividiendo entre 2 hasta llegar a 0. La segunda variable (veces) la usaremos como contador para saber cuántas veces se ejecuta el bucle while. Este número de repeticiones será el número de veces que se ha dividido el valor de num entre 2.

Si te fijas, la condición del bucle while es num>0, lo que significa que mientras el valor de la variable num sea mayor que 0 el bucle se repetirá.

En el cuerpo del bucle (entre las llaves) se realiza la división de num entre 2 y se modifica el valor de num con el resultado de dicha operación (num = num/2). El valor de num se hará más pequeño en cada iteración del bucle llegando en algún momento a valer 0.

Para contar el número de veces que se ha efectuado la división bastará con incrementar el valor de la variable veces en una unidad (veces++). De esta forma, cuando num llegue a 0 y el bucle se detenga porque la condición (num>0) sea false, tendremos en la variable veces almacenado el número de repeticiones efectuadas por el bucle y solo será necesario imprimir su valor (System.out.println(veces)).

El bucle do while en Java

Hemos llegado al último tipo de instrucción de control repetitiva en Java. Este bucle es muy parecido al bucle while que acabamos de ver, la principal diferencia es que el número mínimo de ejecuciones de este bucle es siempre 1, mientras que el número mínimo de ejecuciones del bucle while es 0.

No te preocupes, con un ejemplo lo entenderás mejor, pero vamos a ver primero la sintaxis del bucle do while y cómo utilizar do while en Java.

Sintaxis de la instrucción do while en Java

La sintaxis de la instrucción do while en Java es la siguiente:

do{
    //instrucciones que se repiten
}while(condición);

Como puedes comprobar la condición en este caso se evalúa al final y el bucle comienza con la palabra reservada do. Después de do no hay nada, solo las llaves que encierran el cuerpo del bucle, por tanto, no hay nada que impida la ejecución de las instrucciones que se van a repetir al menos una vez.

Al igual que ocurre con el bucle while, la condición es la responsable de las repeticiones del bucle. Si la evaluación de la condición devuelve como resultado true, entonces el bucle se repite ejecutándose de nuevo desde la linea del do, en caso de devolver false como resultado el bucle se detiene.

Por cierto, este bucle siempre lleva un punto y coma (;) al final, ¡no lo olvides!

¿Parece lioso? No lo es, vamos a ver un ejemplo para que te quede más claro y comprendas cómo funciona el do while.

Ejemplo del bucle do while en Java

Mira el siguiente código:

int num=10;
do{
     num++;
}while(num%2 != 0);
System.out.println(num);

La salida que genera este fragmento de código es la siguiente:

12

Vamos a analizar el código para que lo entiendas.

La primera instrucción es la declaración de la variable num, de tipo int y con valor inicial 10 (int num=10).

A continuación comienza el bucle do while con la palabra reservada do. En este punto no se evalúa la condición, así que se ejecuta la instrucción num++ que está en el cuerpo del bucle (encerrado entre llaves). Como inicialmente la variable num tenía valor 10, ahora tomará valor 11 tras el incremento.

Se ha ejecutado el bucle una vez, ahora es el turno de la instrucción while, responsable de evaluar la condición.

La condición del bucle es (num%2 != 0). Recuerda que el operador % calcula el resto de una división entera, por tanto, lo que está evaluando es si el resto de dividir num entre 2 (num%2) es distinto (!=) de 0, es decir, si num es impar. Como num se incrementó anteriormente, ahora vale 11 (impar). ¿11 % 2 != 0? Si, por tanto la evaluación de la condición es true, lo que hace que el bucle se repita.

Volvemos a do y num++ se ejecuta de nuevo. La variable num pasa a valer 12. ¿Qué devolverá ahora la condición? Pues false, porque 12 es par y al dividirlo entre 2 su resto es 0. No se cumple la condición, por lo que el bucle se detiene y no se producen más repeticiones.

El programa continua con la ejecución de las instrucciones posteriores al bucle, en este caso la instrucción System.out.println(num) que muestra el valor de la variable num por pantalla. La salida generada será 12.

Como puedes ver, la primera ejecución es obligatoria, las siguientes dependen de la condición. ¿Qué pasa si usamos un while en vez de un do while? Vamos a verlo.

While vs do while en Java

Estas dos instrucciones de control repetitivas en Java se parecen mucho, pero hay una diferencia importante y el resultado puede variar mucho entre usar una o la otra.

Vamos a repetir el mismo ejemplo que hice para do while pero utilizando un while:

int num = 10;
while (num%2 != 0){
    num++;
}
System.out.println(num);

En este caso la condición se evalúa siempre antes de ejecutar el cuerpo del bucle.

La variable num tiene valor 10 inicialmente (int num = 10;). Después se ejecuta la instrucción while que evalúa la condición: ¿10 % 2 != 0? No, 10 es par, por tanto el resto de dividirlo entre 2 es 0. No se cumple la condición de desigualdad, así que la evaluación de la condición es false y el bucle se detiene dando paso a la ejecución de la instrucción System.out.println(num) que mostrará por pantalla el valor 10.

Estás en lo cierto, el resultado es distinto al obtenido con el bucle do while. El bucle while ha efectuado 0 repeticiones, por lo que la instrucción num++ nunca se ejecuta. ¿Ves la diferencia?

Espero que te haya servido este artículo para entender qué son y cómo funcionan los bucles en Java.

¡Nos vemos en el próximo artículo!

Mientras puedes seguir aprendiendo programación en Java aquí.

Sígueme: