¿Cuáles son las formas de iterar sobre colecciones en…

En Java, existen varias formas de iterar sobre colecciones:

Bucle for con índice (para colecciones que soportan acceso por índice, como ArrayList, LinkedList):
Adecuado para colecciones donde el acceso por índice es eficiente.

// Ejemplo de iteración sobre ArrayList
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

for (int i = 0; i < list.size(); i++) {
    String element = list.get(i);
    System.out.println(element);
}

Bucle for mejorado (Enhanced for loop / for-each loop):
La forma más común y conveniente para la mayoría de los casos. Adecuado para cualquier colección que implemente Iterable.

// Ejemplo de iteración sobre ArrayList con for-each
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

for (String element : list) {
    System.out.println(element);
}

Uso del iterador (Iterator):
Forma más flexible que permite eliminar elementos durante la iteración. Adecuado para todas las colecciones.

// Ejemplo de iteración usando Iterator
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
    // Se pueden eliminar elementos de forma segura
    // if (element.equals("B")) {
    //     iterator.remove();
    // }
}

Uso de ListIterator (para listas):
Iterador especializado para colecciones que implementan List. Permite moverse hacia adelante y hacia atrás, además de agregar y modificar elementos.

// Ejemplo de iteración con ListIterator
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String element = listIterator.next();
    System.out.println(element);
}
// Ejemplo de iteración hacia atrás
while (listIterator.hasPrevious()) {
    String element = listIterator.previous();
    System.out.println(element);
}

Streams API (desde Java 8):
Enfoque funcional usando expresiones lambda. Permite realizar operaciones sobre los elementos de la colección (filtrado, transformación, etc.) de forma declarativa. La iteración ocurre "internamente" en el flujo.

// Ejemplo de iteración usando Streams API
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

list.stream()
    .forEach(element -> System.out.println(element));

// Ejemplo con filtrado y transformación
// list.stream()
//     .filter(element -> element.startsWith("A"))
//     .map(String::toLowerCase)
//     .forEach(System.out::println);

La elección del método depende de la tarea específica, el tipo de colección y el rendimiento requerido. Para la mayoría de los casos, el bucle for mejorado es el más conveniente. Si se necesita eliminar elementos durante la iteración, se debe usar Iterator. Para listas que requieren iteración bidireccional, ListIterator es adecuado. Streams API ofrece potentes capacidades para procesar datos de forma declarativa.

¿Cuáles son las formas de iterar sobre colecciones en Java?