Bucle for en Java: sintaxis, ejemplos y el for-each mejorado

El clásico bucle for de tres partes

Un bucle for repite un bloque un número controlado de veces. La forma de Java mete tres cosas entre los paréntesis, separadas por punto y coma:

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

Las tres partes se ejecutan con un ritmo fijo:

1. Inicialización (int i = 0) - se ejecuta una vez, antes que nada.
2. Condición (i < 5) - se comprueba antes de cada pasada; el bucle se detiene cuando es falsa.
3. Actualización (i++) - se ejecuta después de cada pasada, antes de volver a comprobar la condición.

Así que esto imprime de i = 0 hasta i = 4. El contador i está acotado al bucle: no existe después de la llave de cierre.

Contar hacia arriba, hacia abajo y por pasos

Las tres partes te dan control total sobre el contador:

public class Main {
    public static void main(String[] args) {
        for (int i = 10; i > 0; i--) {       // cuenta hacia abajo
            System.out.print(i + " ");
        }
        System.out.println();

        for (int i = 0; i <= 20; i += 5) {   // avanza de 5 en 5
            System.out.print(i + " ");
        }
    }
}

i-- decrementa, i += 5 salta en pasos de cinco. La condición decide la parada según la dirección: usa > cuando cuentas hacia abajo, y < o <= cuando cuentas hacia arriba.

Recorrer un array

Un bucle contado encaja de forma natural con un array, usando .length como límite e i como índice:

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        for (int i = 0; i < colors.length; i++) {
            System.out.println(i + ": " + colors[i]);
        }
    }
}

Fíjate en que colors.length es un campo sin paréntesis: los arrays son especiales en eso. Una List usa en cambio list.size(). La condición i < colors.length es correcta: los índices van de 0 a length - 1, así que usar < (y no <=) evita un error de fuera de límites.

El bucle for-each mejorado

Cuando solo necesitas cada elemento y nunca el índice, el for mejorado es más limpio y más difícil de equivocar: no hay contador con el que cometer un error por uno:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> colors = List.of("red", "green", "blue");

        for (String color : colors) {
            System.out.println(color.toUpperCase());
        }
    }
}

Lee for (String color : colors) como "para cada color en colors". Funciona con arrays y con cualquier cosa iterable. El compromiso: no tienes índice y no puedes añadir ni quitar elementos de la colección mientras la recorres (eso lanza ConcurrentModificationException). Recurre al bucle contado cuando necesites cualquiera de las dos cosas.

Bucles anidados

Un bucle dentro de otro bucle: útil para cuadrículas, tablas y emparejamientos. El bucle interno se ejecuta por completo en cada pasada del externo:

public class Main {
    public static void main(String[] args) {
        for (int row = 1; row <= 3; row++) {
            for (int col = 1; col <= 3; col++) {
                System.out.print(row * col + "\t");
            }
            System.out.println();
        }
    }
}

Esto imprime una cuadrícula de multiplicación de 3x3. Dales a los contadores nombres con sentido (row, col) en lugar de i, j cuando el anidamiento se vuelve profundo: te ahorra confundir cuál es cuál.

break y continue

break sale del bucle de inmediato. continue se salta el resto de la pasada actual y salta al paso de actualización:

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue;   // salta los números pares
            if (i > 7) break;           // detente al pasar de 7
            System.out.println(i);
        }
    }
}

Esto imprime 1 3 5 7. continue se salta los pares; break termina el bucle en cuanto i superaría 7. En bucles anidados, ambos afectan solo al bucle más interno, salvo que uses un break etiquetado.

Cuidado con los bucles infinitos

Si la condición nunca se vuelve falsa, el bucle se ejecuta para siempre. La causa habitual es olvidar la actualización o mover el contador en la dirección equivocada:

for (int i = 0; i < 5; i--) {   // i solo disminuye -> nunca llega a 5
    System.out.println(i);
}

Un bucle infinito intencionado omite las tres partes -for (;;) { ... }- y depende de un break interior para detenerse. Úsalo con moderación; un while (true) suele leerse con más claridad.

Siguiente: bucles while

El bucle for brilla cuando conoces el contador de antemano. Cuando quieres iterar hasta que cambie alguna condición -y no tienes un contador claro-, el bucle while encaja mejor. Esa es la siguiente página.