Iterando coleções em Java: for-each, Iterator, forEach

Um trabalho, várias ferramentas

Você reuniu alguns dados - em um ArrayList, um HashSet, um HashMap - e agora quer visitar cada elemento. Java oferece algumas maneiras de fazer isso, e qual você escolhe depende de se você precisa do índice, de se precisa remover itens no meio do laço e de se prefere uma sintaxe de método ou de laço.

A boa notícia: cada Collection (lista, conjunto, fila) suporta o mesmo laço for aprimorado, então, depois de aprendê-lo, você pode iterar todas elas da mesma forma.

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

Leia os dois-pontos como "em": "para cada lang em langs". Você nunca toca em um índice, então não há nada para errar.

O laço for-each

O for aprimorado é a escolha padrão para o simples "faça algo com cada elemento". Ele se lê com clareza e funciona de forma idêntica entre os tipos de coleção - aqui um HashSet, que não tem índices nenhum:

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("urgent");
        tags.add("review");
        tags.add("urgent");   // duplicata ignorada por um Set

        for (String tag : tags) {
            System.out.println(tag);
        }
    }
}

Uma coisa para lembrar sobre um HashSet: ele não tem ordem definida, então os elementos podem ser impressos em qualquer sequência. O for-each visita todos eles exatamente uma vez, de qualquer forma.

Quando você precisa do índice

O for-each fornece o elemento, mas não a sua posição. Se você realmente precisa do índice - para numerar linhas ou para olhar os elementos vizinhos - use um laço contado com size() e get(i). Isso funciona em uma List, que é posicional; conjuntos e mapas não têm índice, então esse estilo não se aplica a eles.

import java.util.List;

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

        for (int i = 0; i < langs.size(); i++) {
            System.out.println((i + 1) + ". " + langs.get(i));
        }
    }
}

Não recorra a isso só por hábito. Se você não está usando i para nada além de get(i), a versão com for-each é mais curta e mais difícil de errar.

Iterando um Map

Um Map não é uma Collection, então você não pode fazer for-each diretamente sobre ele. Em vez disso, você percorre uma de suas três visões. A mais comum é entrySet(), que entrega cada par chave-valor junto:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 28);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Se você só precisa das chaves, percorra ages.keySet(); se você só precisa dos valores, percorra ages.values(). Prefira entrySet() quando precisar de ambos - percorrer as chaves e depois chamar ages.get(key) dentro faz uma segunda busca a cada iteração sem motivo nenhum.

O Iterator

O for-each é, na verdade, açúcar sintático sobre um Iterator - um objeto que percorre uma coleção um elemento por vez via hasNext() e next(). Você raramente escreve esse laço à mão, com uma exceção importante: é a forma segura de remover elementos durante a iteração.

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));

        Iterator<Integer> it = nums.iterator();
        while (it.hasNext()) {
            int n = it.next();
            if (n % 2 == 0) {
                it.remove();   // seguro: remove o elemento recém-retornado
            }
        }

        System.out.println(nums);
    }
}

it.remove() apaga o elemento que next() retornou por último, e o iterador permanece válido. Esta é a única forma autorizada de modificar uma coleção durante um laço manual.

A armadilha: ConcurrentModificationException

Se você chamar add ou remove na própria coleção dentro de um laço for-each, recebe uma ConcurrentModificationException - o iterador percebe que a coleção mudou por baixo dele e se recusa a continuar. Este é um dos erros em tempo de execução de iniciante mais comuns.

List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4));
for (int n : nums) {
    if (n % 2 == 0) {
        nums.remove(Integer.valueOf(n));   // throws ConcurrentModificationException
    }
}

A correção é quase sempre removeIf, que expressa a intenção em uma única linha e cuida da iteração para você:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // descarta os números pares
        System.out.println(nums);
    }
}

removeIf funciona em qualquer Collection, então a mesma chamada também limpa um HashSet.

O método forEach

Toda coleção também tem um método forEach que recebe uma lambda e a executa sobre cada elemento. É uma alternativa mais funcional, em estilo de expressão, ao laço - prática para frases curtas de uma linha:

import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 28);
        ages.forEach((name, age) -> System.out.println(name + ": " + age));
    }
}

Note que Map.forEach recebe diretamente uma lambda de dois argumentos (key, value) - sem precisar de entrySet(). Use forEach para efeitos colaterais rápidos; volte ao laço for comum quando o corpo crescer ou você precisar de break para sair mais cedo, algo que uma lambda não pode fazer.

Próximo: Métodos

Você já empacotou dados em coleções e os percorreu de todas as formas que Java oferece. O próximo passo é empacotar comportamento: escrever seus próprios métodos para poder dar nome a um bloco de lógica, passar entradas a ele e reutilizá-lo - que é a próxima página.