Iterar colecciones en Java: for-each, Iterator, forEach

Un trabajo, varias herramientas

Has recopilado algunos datos - en un ArrayList, un HashSet, un HashMap - y ahora quieres visitar cada elemento. Java te ofrece varias formas de hacerlo, y la que elijas depende de si necesitas el índice, de si necesitas eliminar elementos a mitad del bucle y de si prefieres una sintaxis de método o de bucle.

La buena noticia: cada Collection (lista, conjunto, cola) admite el mismo bucle for mejorado, así que una vez que lo aprendes puedes iterarlas todas de la misma manera.

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

Lee los dos puntos como "en": "para cada lang en langs". Nunca tocas un índice, así que no hay nada que hacer mal.

El bucle for-each

El for mejorado es la opción por defecto para el típico "haz algo con cada elemento". Se lee con claridad y funciona igual en todos los tipos de colección; aquí un HashSet, que no tiene índices en absoluto:

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");   // el Set ignora el duplicado

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

Una cosa que recordar sobre un HashSet: no tiene un orden definido, así que los elementos pueden imprimirse en cualquier secuencia. El for-each los visita todos exactamente una vez de todos modos.

Cuando necesitas el índice

El for-each te da el elemento pero no su posición. Si realmente necesitas el índice - para numerar líneas o para mirar elementos vecinos - usa un bucle contado con size() y get(i). Esto funciona en una List, que es posicional; los conjuntos y mapas no tienen índice, así que este estilo no se les aplica.

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

No recurras a esto solo por costumbre. Si no usas i para nada más que get(i), la versión con for-each es más corta y más difícil de equivocar.

Iterar un Map

Un Map no es una Collection, así que no puedes hacer for-each directamente sobre él. En su lugar, recorres una de sus tres vistas. La más común es entrySet(), que te entrega cada par clave-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());
        }
    }
}

Si solo necesitas las claves, recorre ages.keySet(); si solo necesitas los valores, recorre ages.values(). Prefiere entrySet() cuando necesites ambos: recorrer las claves y luego llamar a ages.get(key) dentro hace una segunda búsqueda en cada iteración sin ninguna razón.

El Iterator

El for-each es en realidad azúcar sintáctico sobre un Iterator: un objeto que recorre una colección un elemento a la vez mediante hasNext() y next(). Rara vez escribes este bucle a mano, con una excepción importante: es la forma segura de eliminar elementos mientras iteras.

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: elimina el elemento recién devuelto
            }
        }

        System.out.println(nums);
    }
}

it.remove() borra el elemento que next() devolvió la última vez, y el iterador sigue siendo válido. Esta es la única forma autorizada de mutar una colección durante un bucle manual.

La trampa: ConcurrentModificationException

Si llamas a add o remove sobre la propia colección dentro de un bucle for-each, obtienes una ConcurrentModificationException: el iterador se da cuenta de que la colección cambió bajo sus pies y se niega a continuar. Este es uno de los errores de principiante más comunes.

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

La solución es casi siempre removeIf, que expresa la intención en una sola línea y se encarga de la iteración por ti:

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);   // elimina los números pares
        System.out.println(nums);
    }
}

removeIf funciona en cualquier Collection, así que la misma llamada también limpia un HashSet.

El método forEach

Cada colección tiene además un método forEach que recibe una lambda y la ejecuta sobre cada elemento. Es una alternativa más funcional, de estilo expresión, al bucle, práctica para frases cortas de una línea:

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

Fíjate en que Map.forEach recibe directamente una lambda de dos argumentos (key, value) - sin necesidad de entrySet(). Usa forEach para efectos secundarios rápidos; vuelve al bucle for normal cuando el cuerpo crece o necesitas hacer break para salir antes, algo que una lambda no puede hacer.

Siguiente: Métodos

Ya has empaquetado datos en colecciones y los has recorrido de todas las formas que ofrece Java. El siguiente paso es empaquetar comportamiento: escribir tus propios métodos para poder dar nombre a un bloque de lógica, pasarle entradas y reutilizarlo, que es la siguiente página.