Loop for em Java: sintaxe, exemplos e o for-each aprimorado

O clássico loop for de três partes

Um loop for repete um bloco um número controlado de vezes. A forma do Java junta três coisas dentro dos parênteses, separadas por ponto e vírgula:

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

As três partes rodam num ritmo fixo:

1. Inicialização (int i = 0) - roda uma vez, antes de tudo.
2. Condição (i < 5) - verificada antes de cada passagem; o loop para quando ela é falsa.
3. Atualização (i++) - roda após cada passagem, antes de a condição ser verificada de novo.

Então isso imprime de i = 0 até i = 4. O contador i tem escopo restrito ao loop - ele não existe depois da chave de fechamento.

Contar para cima, para baixo e em passos

As três partes te dão controle total sobre o contador:

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

        for (int i = 0; i <= 20; i += 5) {   // avança de 5 em 5
            System.out.print(i + " ");
        }
    }
}

i-- decrementa, i += 5 salta em passos de cinco. A condição decide a parada conforme a direção: use > ao contar para baixo, e < ou <= ao contar para cima.

Percorrer um array

Um loop contado combina naturalmente com um array, usando .length como limite 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]);
        }
    }
}

Repare que colors.length é um campo sem parênteses - os arrays são especiais nesse ponto. Uma List, por sua vez, usa list.size(). A condição i < colors.length está correta: os índices vão de 0 a length - 1, então usar < (e não <=) evita um erro de fora dos limites.

O loop for-each aprimorado

Quando você só precisa de cada elemento e nunca do índice, o for aprimorado é mais limpo e mais difícil de errar - não há contador para um erro de off-by-one:

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());
        }
    }
}

Leia for (String color : colors) como "para cada color em colors". Funciona com arrays e qualquer coisa iterável. O custo: você não tem índice e não pode adicionar nem remover da coleção enquanto a percorre (isso lança ConcurrentModificationException). Recorra ao loop contado quando precisar de qualquer um dos dois.

Loops aninhados

Um loop dentro de outro loop - útil para grades, tabelas e pares. O loop interno roda por completo a cada passagem do 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();
        }
    }
}

Isso imprime uma grade de multiplicação 3x3. Dê aos contadores nomes significativos (row, col) em vez de i, j quando o aninhamento ficar profundo - isso evita que você confunda qual é qual.

break e continue

break sai do loop imediatamente. continue pula o resto da passagem atual e salta para o passo de atualização:

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

Isso imprime 1 3 5 7. continue pula os pares; break encerra o loop assim que i ultrapassaria 7. Em loops aninhados, ambos afetam apenas o loop mais interno, a menos que você use um break rotulado.

Cuidado com loops infinitos

Se a condição nunca ficar falsa, o loop roda para sempre. A causa comum é esquecer a atualização ou mover o contador na direção errada:

for (int i = 0; i < 5; i--) {   // i só diminui -> nunca chega a 5
    System.out.println(i);
}

Um loop infinito intencional omite as três partes -for (;;) { ... }- e conta com um break interno para parar. Use com moderação; um while (true) costuma ser mais claro de ler.

Próximo: loops while

O loop for brilha quando você conhece o contador de antemão. Quando você quer iterar até que alguma condição mude - e não tem um contador claro -, o loop while se encaixa melhor. Essa é a próxima página.