Loop for-each em Java: sintaxe, exemplos e pegadinhas

Quando o índice só atrapalha

Um loop for com contador dá a você um contador, uma condição e um passo de atualização. Mas em grande parte do tempo você não se importa de verdade com a posição de um elemento: você só quer fazer algo com cada um, em ordem, do início ao fim. Gerenciar um índice para isso é trabalho à toa, e é exatamente onde os erros de off-by-one se infiltram.

O loop for-each (o nome que o Java dá a ele é for melhorado) elimina o contador por completo. Você nomeia uma variável, aponta-a para uma coleção e o loop entrega cada elemento por vez.

Sintaxe básica

A forma é for (Tipo elemento : colecao). Leia os dois-pontos como a palavra "em":

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 100};

        for (int score : scores) {
            System.out.println("Score: " + score);
        }
    }
}

Não há i, nem scores.length, nem scores[i]. A cada passagem, score é o próximo elemento. O loop roda uma vez por elemento e para automaticamente quando não há mais nenhum: você não pode passar do fim nem começar um elemento cedo demais.

Percorrendo uma lista

O mesmo loop funciona com qualquer coisa iterável, o que inclui List, Set e os outros tipos de coleção. O tipo do elemento vem antes do nome da variável:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang + " has " + lang.length() + " letters");
        }
    }
}

Repare que você não precisou saber nem se importar se langs é apoiada por um array, uma lista encadeada ou qualquer outra coisa: o for-each funciona igual em todas elas. Essa é a sua verdadeira força: uma sintaxe legível para toda coleção.

var poupa você de escrever o nome do tipo

Se o tipo do elemento for longo ou óbvio, var deixa o compilador inferi-lo para você não se repetir:

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.of("Ann", 30, "Bo", 25);

        for (var entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Sem var, essa variável do loop seria o trava-língua Map.Entry<String, Integer>. var mantém tudo legível, e o tipo continua totalmente verificado em tempo de compilação: não é um tipo solto e dinâmico.

A pegadinha da modificação

Aqui está a regra que confunde todo mundo: você não pode adicionar nem remover de uma coleção enquanto um loop for-each a percorre. Fazer isso lança uma ConcurrentModificationException:

List<String> items = new ArrayList<>(List.of("a", "b", "c"));

for (String item : items) {
    if (item.equals("b")) {
        items.remove(item);   // lança ConcurrentModificationException
    }
}

O loop percebe que a lista mudou por baixo dele e interrompe a execução em vez de pular ou repetir elementos silenciosamente. Para remover com segurança, desça para um Iterator explícito, que tem um remove() que o loop conhece:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("a", "b", "c"));

        Iterator<String> it = items.iterator();
        while (it.hasNext()) {
            if (it.next().equals("b")) {
                it.remove();   // seguro
            }
        }

        System.out.println(items);   // [a, c]
    }
}

Um atalho comum é items.removeIf(item -> item.equals("b")), que faz a mesma coisa em uma única linha.

Apenas leitura, sem reatribuir

Outra limitação sutil: atribuir à variável do loop muda apenas a cópia local, não a coleção. Isso surpreende quem vem de linguagens em que a variável do loop é uma referência viva:

public class Main {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};

        for (int n : nums) {
            n = n * 10;   // muda a cópia, não o array
        }

        System.out.println(nums[0]);   // continua 1
    }
}

Se você precisa escrever de volta no array, precisa do índice, e isso significa o clássico loop for com contador: for (int i = 0; i < nums.length; i++) nums[i] = nums[i] * 10;. Para elementos que são objetos, você pode alterar o objeto para o qual a variável aponta (chamando um setter, por exemplo), mas não pode substituí-lo na coleção.

break e continue continuam funcionando

Um for-each é um loop de verdade, então break e continue se comportam exatamente como em qualquer outro lugar: break sai do loop, continue pula para o próximo elemento:

public class Main {
    public static void main(String[] args) {
        String[] words = {"keep", "skip", "keep", "stop", "never"};

        for (String w : words) {
            if (w.equals("skip")) continue;   // ignora este
            if (w.equals("stop")) break;      // sai de vez
            System.out.println(w);
        }
    }
}

Isso imprime keep e depois keep: ele pula "skip" e para em "stop" antes de chegar a "never". Então você não é obrigado a visitar todos os elementos; você apenas abre mão do índice em troca de um código mais limpo.

Próximo: Arrays

Você já percorreu arrays algumas vezes sem se deter no que eles realmente são: contêineres indexados de tamanho fixo com aquele campo .length. A próxima página volta ao início e cobre os arrays como deve ser: como declará-los, os valores padrão com que eles começam e como o seu tamanho fixo se diferencia de um ArrayList que pode crescer.