Bucle while en Java: sintaxis, do-while y errores comunes

Cuando no tienes un contador

El bucle for se construye en torno a un contador que defines de antemano. Pero muchos bucles no tienen una cuenta clara: seguir leyendo líneas hasta que termine el archivo, seguir pidiendo una contraseña hasta que sea correcta, seguir dividiendo un número entre dos hasta que llegue a 1. Para esos casos, el bucle while encaja de forma natural: simplemente se repite mientras una condición siga siendo verdadera.

Un bucle while comprueba su condición antes de cada pasada, incluida la primera. Si la condición es falsa desde el principio, el cuerpo no se ejecuta nunca.

public class Main {
    public static void main(String[] args) {
        int count = 3;

        while (count > 0) {
            System.out.println("Liftoff in " + count);
            count--;
        }

        System.out.println("Go!");
    }
}

La condición count > 0 se comprueba primero; si es verdadera, se ejecuta el cuerpo; luego volvemos al inicio y comprobamos de nuevo. La línea count-- es lo que finalmente hace falsa la condición; quítala y el bucle se ejecutará para siempre.

La anatomía de un bucle while

Compáralo con el bucle for de tres partes que ya conoces. Un bucle while separa esos tres trabajos: la inicialización la haces antes del bucle, la condición va entre paréntesis y la actualización vive dentro del cuerpo.

int i = 0;              // inicialización - antes del bucle
while (i < 5) {         // condición - se comprueba en cada pasada
    System.out.println(i);
    i++;                // actualización - debes recordarla tú mismo
}

Esa última parte es la trampa. En un bucle for la actualización está justo al lado de la condición, así que es difícil olvidarla. En un bucle while es solo otra instrucción más del cuerpo: el error más común es dejarla fuera y colgar el programa.

do-while: ejecutar el cuerpo al menos una vez

A veces necesitas que el cuerpo se ejecute una vez antes de poder siquiera decidir si repetir. El bucle do-while comprueba su condición al final, así que el cuerpo siempre se ejecuta al menos una vez:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int number;

        do {
            System.out.print("Enter a positive number: ");
            number = in.nextInt();
        } while (number <= 0);

        System.out.println("Thanks! You entered " + number);
    }
}

Tienes que pedir y leer al menos una vez antes de poder saber si la entrada es válida, que es exactamente lo que te da el do-while. Fíjate en el punto y coma después de while (...): es obligatorio, y olvidarlo es un error de compilación frecuente.

La diferencia con un while normal se ve claramente cuando la condición es falsa desde el principio:

public class Main {
    public static void main(String[] args) {
        int x = 10;

        // while: condición falsa de entrada -> el cuerpo nunca se ejecuta
        while (x < 5) {
            System.out.println("while body");
        }

        // do-while: se ejecuta una vez y LUEGO comprueba -> el cuerpo se ejecuta exactamente una vez
        do {
            System.out.println("do-while body");
        } while (x < 5);
    }
}

Solo se imprime do-while body. El bucle while se salta su cuerpo por completo porque x < 5 era falso antes de la primera comprobación.

Iterar hasta un valor centinela

Un uso clásico de while es leer hasta un valor especial de "parada": un centinela. Aquí no hay contador; simplemente sigues hasta que los datos te dicen que pares:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = 0;

        System.out.println("Enter numbers to add (0 to finish):");
        int value = in.nextInt();

        while (value != 0) {
            sum += value;
            value = in.nextInt();
        }

        System.out.println("Total: " + sum);
    }
}

El patrón es leer una vez antes del bucle y luego volver a leer al final de cada pasada. Así la condición siempre prueba una entrada nueva. Si olvidas la segunda lectura dentro del cuerpo, value nunca cambia y tienes un bucle infinito.

break y continue en bucles while

break y continue funcionan aquí igual que en un bucle for. break sale del bucle de inmediato; continue salta directamente a la comprobación de la condición, omitiendo el resto de la pasada actual:

public class Main {
    public static void main(String[] args) {
        int n = 0;

        while (true) {              // "bucle infinito" intencionado
            n++;
            if (n % 2 == 0) continue;   // omite los números pares
            if (n > 9) break;           // se detiene al pasar de 9
            System.out.println(n);
        }
    }
}

Esto imprime 1 3 5 7 9. El while (true) deliberadamente nunca se detiene por sí solo: el break es la única salida. Ten cuidado con continue en un bucle while: como la actualización forma parte del cuerpo, saltar de nuevo al inicio con continue antes de haber avanzado el contador es una forma silenciosa de colgar el bucle. En el ejemplo anterior n++ se ejecuta primero, así que es seguro.

Cuidado con los bucles infinitos

La condición tiene que acabar siendo falsa, y eso depende por completo de que algo dentro del cuerpo cambie. Los dos culpables habituales son olvidar la actualización y actualizar de forma equivocada:

int i = 0;
while (i < 5) {
    System.out.println(i);   // i nunca cambia -> se ejecuta para siempre
}

int i = 0;
while (i != 10) {
    i += 3;   // 0, 3, 6, 9, 12... pasa de largo el 10 -> se ejecuta para siempre
}

El primero se cuelga porque i nunca se actualiza. El segundo se cuelga porque el contador salta por encima del valor exacto que busca la condición; prefiere < o <= frente a != cuando el paso podría no caer justo. Un while (true) está bien si tiene un break garantizado; uno accidental no es más que un error.

Siguiente: el bucle for-each

Un bucle while es la herramienta adecuada cuando iteras hasta que cambie una condición y no hay una cuenta clara. Pero cuando simplemente quieres visitar cada elemento de un array o una lista (sin índice, sin condición que gestionar) hay algo aún más limpio: el bucle for-each mejorado. Esa es la siguiente página.