Quais são as formas de iterar sobre coleções em Java…

Em Java, existem várias formas de iterar sobre coleções:

Ciclo for com índice (para coleções que suportam acesso por índice, como ArrayList, LinkedList):
Adequado para coleções onde o acesso por índice é eficiente.

// Exemplo de iteração 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);
}

Ciclo for melhorado (for-each):
A forma mais comum e conveniente para a maioria dos casos. Adequado para qualquer coleção que implemente Iterable.

// Exemplo de iteração sobre ArrayList com 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 do iterador (Iterator):
Forma mais flexível que permite remover elementos durante a iteração. Adequado para todas as coleções.

// Exemplo de iteração 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);
    // Pode remover elementos de forma segura
    // if (element.equals("B")) {
    //     iterator.remove();
    // }
}

Uso de ListIterator (para listas):
Iterador especializado para coleções que implementam List. Permite mover-se para frente e para trás, além de adicionar e modificar elementos.

// Exemplo de iteração com 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);
}
// Exemplo de iteração para trás
while (listIterator.hasPrevious()) {
    String element = listIterator.previous();
    System.out.println(element);
}

Streams API (a partir do Java 8):
Abordagem funcional usando expressões lambda. Permite realizar operações nos elementos da coleção (filtragem, transformação, etc.) de forma declarativa. A iteração ocorre "internamente" no fluxo.

// Exemplo de iteração 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));

// Exemplo com filtragem e transformação
// list.stream()
//     .filter(element -> element.startsWith("A"))
//     .map(String::toLowerCase)
//     .forEach(System.out::println);

A escolha do método depende da tarefa específica, do tipo de coleção e do desempenho necessário. Para a maioria dos casos, o ciclo for melhorado é o mais conveniente. Se for necessário remover elementos durante a iteração, deve-se usar Iterator. Para listas que requerem iteração bidirecional, ListIterator é adequado. A API Streams oferece recursos poderosos para processar dados de forma declarativa.

Quais são as formas de iterar sobre coleções em Java?