El bucle while de Java

Comencemos con una parte interesante del curso, los bucles. Concretamente, te voy a mostrar la sintaxis y funcionamiento del bucle while de Java.

¿Qué es un bucle en programación?

Los bucles son estructuras de control de flujo, como los condicionales. Con la gran diferencia, que estos están diseñados para repetir bloques de código mientras se cumpla cierta condición.

En Java contamos con más de un tipo de bucle, sin embargo, en este capítulo, solo hablaré del bucle while.

Sintaxis del bucle while de Java

En principio, la sintaxis recuerda mucho a la del condicional if, sin embargo, hay ciertas diferencias fundamentales.

iterador;

while (condición) {
	//Bloque de código
  	incremento/decremento;
}

Te dejo aquí un ejemplo sencillo de bucle while con todos sus elementos:

public class Main {
    public static void main(String[] args) {
        //--> Bucle while
        int i = 0; //iterador

        while (i < 10) {
            System.out.println("El valor es: " + i);
            i++; //incremento
        }
    }
}

Resultado en la consola

El valor es: 0
El valor es: 1
El valor es: 2
El valor es: 3
El valor es: 4
El valor es: 5
El valor es: 6
El valor es: 7
El valor es: 8
El valor es: 9

Analicemos lo que ocurre aquí.

El bucle necesita una variable de control (iterador) para funcionar. Por convención y para que sea fácil de identificar, se suele poner «i» como nombre identificador. Aunque puede que en ciertas ocasiones, lo veas también con «n».

Esto son solo convenciones, puedes darle un nombre de identificador cualquiera. Eso si, que sea válido según las normas de nomenclatura de Java.

Esta variable está inicializada en 0. No obstante, puede ser cualquier valor numérico, no importa que sea un 0.

En la expresión del while, lo que he puesto es que el bucle se ejecute mientras el valor de «i» sea menor que 10.

Puesto que 0 es menor que 10, esto se cumple. La expresión devuelve «true». Por este motivo, al igual que ocurre con el condicional if, si devuelve «true» la expresión, se ejecuta el bloque de código de la estructura.

Si esto fuese un condicional if, se imprimiría el texto del print() con «El valor es: 0» y nada más, ahí termina la cosa.

public class Main {
    public static void main(String[] args) {
        //--> Bucle while
        int i = 0; //iterador

        if (i < 10) {
            System.out.println("El valor es: " + i);
        }
    }
}

Resultado en la consola

El valor es: 0

No obstante, los bucles se repiten siempre si la expresión sigue siendo verdadera.

Si quitamos la parte del incremento (la última línea del bucle), verás que el bucle da un valor de 0 infinitamente (no ejecutes este código, puede dejar colgado tu equipo).

public class Main {
    public static void main(String[] args) {
        //--> Bucle while
        int i = 0; //iterador

        while (i < 10) {
            System.out.println("El valor es: " + i);
        }
    }
}

Resultado en la consola

El valor es: 0
El valor es: 0
El valor es: 0
El valor es: 0
… INFINITO

Puesto que «i» siempre vale 0, se cumple siempre la condición de «i < 10». Por lo tanto, si queremos implementar un mecanismo para que el bucle no se repita infinitamente, sino que cumpla su función y luego finalice, vamos a utilizar incrementos y decrementos.

Los bucles infinitos, como estos, muchas veces surgen por errores de lógica, aunque habrá ocasiones, en las que necesitemos bucles infinitos a propósito. Todo depende de lo que queramos hacer.

Incrementos y decrementos en bucles

Los incrementos o decrementos, son mecanismos necesarios a la hora de trabajar con bucles.

El operador aritmético de incremento («++») incrementa el valor de una variable en 1 cuando es ejecutado.

El operador aritmético de decremento («–«) decrementa el valor de una variable en 1 cuando es ejecutado.

Entonces, si dejamos el bucle con el incremento, ocurrirá lo siguiente…

//--> Bucle while

int i = 0; //iterador

while (i < 10) {
	System.out.println("El valor es: " + i);
    i++;
}

A las ejecuciones de los bucles, se les llama frecuentemente como iteraciones. Cada vez que se repite su bloque de código, es una iteración.

• Iteración 1:
  • Inicialmente, «i» vale 0.
  • Se lee la condición del while. Esta devuelve «true».
  • Se imprime en la consola «El valor es: 0».
  • Finalmente, se incrementa el valor de «i» en 1.
• Iteración 2:
  • Inicialmente, «i» vale 1.
  • Se lee la condición del while. Esta devuelve «true».
  • Se imprime en la consola «El valor es: 1».
  • Finalmente, se incrementa el valor de «i» en 1.
• Iteración 3:
  • Inicialmente, «i» vale 2.
  • Se lee la condición del while. Esta devuelve «true».
  • Se imprime en la consola «El valor es: 2».
  • Finalmente, se incrementa el valor de «i» en 1.
• … (omito escribir todas las iteraciones para no repetirme tanto).
• Iteración 10:
  • Inicialmente, «i» vale 9.
  • Se lee la condición del while. Esta devuelve «true».
  • Se imprime en la consola «El valor es: 9».
  • Finalmente, se incrementa el valor de «i» en 1.
• Iteración 11:
  • Inicialmente, «i» vale 10.
  • Se lee la condición del while. Esta devuelve «false» (10 no es menor que 10).
  • Al devolver «false», no se ejecuta nada más del bucle. Ha finalizado.

Te dejo también un ejemplo utilizando el decremento, es lo mismo, solo que restando:

public class Main {
    public static void main(String[] args) {
        //--> Bucle while
        int i = 10; //iterador

        while (i > 0) {
            System.out.println("El valor es: " + i);
            i--;
        }
    }
}

Resultado en la consola

El valor es: 10
El valor es: 9
El valor es: 8
El valor es: 7
El valor es: 6
El valor es: 5
El valor es: 4
El valor es: 3
El valor es: 2
El valor es: 1

Esta vez, el valor de «i» inicialmente es 10. La expresión es que se ejecute mientras «i» sea mayor que 0. Cada iteración del bucle, se va restando o decrementando el valor de «i». En el momento en el que vale 0, el bucle while recibe un «false» en su condición. Ahí termina.

El orden del incremento y decremento

Algo importante a tener en cuenta, es el orden en el flujo de ejecución del incremento y el decremento. Te dejo un ejemplo:

public class Main {
    public static void main(String[] args) {
        //--> Bucle while
        int i = 0; //iterador

        while (i < 10) {
            i++;
            System.out.println("El valor es: " + i);
        }
    }
}

Resultado en la consola

El valor es: 1
El valor es: 2
El valor es: 3
El valor es: 4
El valor es: 5
El valor es: 6
El valor es: 7
El valor es: 8
El valor es: 9
El valor es: 10

Antes, este mismo bucle, imprimía desde el valor 0 hasta el 9 (10 iteraciones) y ahora, lo hace desde el 1 hasta el 10 (10 iteraciones).

Esto está pasando, porque he invertido el flujo de ejecución dentro del bloque de código del while.

• Iteración 1:
  • Inicialmente, «i» vale 0.
  • La condición del while es «true».
  • Se incrementa el valor de «i» en 1.
  • Al imprimir, «i» vale 1. Se ha incrementado antes de imprimir.

Diagrama de flujo del bucle while de Java

Finalmente, te dejo el diagrama de flujo del bucle while de Java, para que veas la gran sencillez que alberga en realidad un bucle.

Simplemente, mientras vaya devolviendo «true», se irán repitiendo las instrucciones del bloque de código. En cuanto devuelve «false», se deja de ejecutar.

Dejamos aquí el bucle while. Lo seguiremos utilizando en más ocasiones y verás usos más prácticos que estos.

Todo el temario del curso Java aquí.

Ejercicios de Java

Te dejo unos ejercicios relacionados con el temario. Las soluciones, las encontrarás en el siguiente capítulo.

1. Arregla los fallos de este código si los hay.

while (i > 10) {
	System.out.println("El valor es: " + i);
}

2. Sin ejecutar este código, ¿Qué respuesta crees que es la correcta?

public class Main {
    public static void main(String[] args) {
        //--> Bucle while
        int i = 1; //iterador

        while (i > 5) {
            System.out.println("El valor es: " + i);
          	i++;
        }
    }
}

• Se ejecuta 5 veces.
• Se ejecuta 4 veces.
• No se ejecuta.
• Es infinito.

3. Sin ejecutar este código, ¿Qué respuesta crees que es la correcta?

public class Main {
    public static void main(String[] args) {
        //--> Bucle while
        int i = 1; //iterador

        while (i < 5) {
            System.out.println("El valor es: " + i);
            i++;
        }
    }
}

• Se ejecuta 5 veces.
• Se ejecuta 4 veces.
• No se ejecuta.
• Es infinito.

4. Sin ejecutar este código, ¿Qué respuesta crees que es la correcta?

public class Main {
    public static void main(String[] args) {
        //--> Bucle while
        int i = 1; //iterador

        while (i < 5) {
            System.out.println("El valor es: " + i);
        }
    }
}

• Se ejecuta 5 veces.
• Se ejecuta 4 veces.
• No se ejecuta.
• Es infinito.

5. Crea un bucle while con las siguientes características:

• Iterador con un valor inicial de 100.
• Que imprima la frase «El valor del bucle es: 100» hasta llegar a 125. Este último valor, también incluido.

Soluciones de los ejercicios del capítulo anterior

1. Los fallos eran los siguientes:
   • El tipo de dato byte, no se correspondía con el valor «200» de la variable «error». Lo puedes cambiar por alguno mayor como short o int.
   • La expresión del switch estaba sin los paréntesis.
   • A todos los case y default, les faltaban los dos puntos.
   • En el case 500, la instrucción que lleva, le falta el punto y coma al final.
   • Faltan todos los «break;».

public class Main {
    public static void main(String[] args) {
        //variables del programa
        int error = 200;

        //condicional switch
        switch (error) {
            case 200:
                System.out.println("Todo ok.");
            	break;
            case 301:
                System.out.println("Movimiento permanente de la página.");
            	break;
            case 302:
                System.out.println("Movimiento temporal de la página.");
            	break;
            case 404:
                System.out.println("Página no encontrada.");
            	break;
            case 500:
                System.out.println("Error interno del servidor.");
            	break;
            case 503:
                System.out.println("Servicio no disponible.");
            	break;
            default:
                System.out.println("Código de error no disponible.");
        }
    }
}

2. Esta sería una posible solución. He decidido utilizar una constante en lugar de una variable, puesto que los días de la semana, son siempre 7, va a ser un valor que no va a cambiar nunca. Por lo tanto, puede ser un buen sitio para utilizar una constante.

public class Main {
    public static void main(String[] args) {
        //variables del programa
        final int SEMANA = 5;

        //condicional switch
        switch (SEMANA) {
            case 1:
                System.out.println("Es lunes.");
                break;
            case 2:
                System.out.println("Es martes.");
                break;
            case 3:
                System.out.println("Es miércoles.");
                break;
            case 4:
                System.out.println("Es jueves.");
                break;
            case 5:
                System.out.println("Es viernes.");
                break;
            case 6:
                System.out.println("Es sábado.");
                break;
            case 7:
                System.out.println("Es domingo.");
                break;
            default:
                System.out.println("Día de la semana inválido.");
        }
    }
}