Maneiras de iterar sobre uma lista em Java

Sendo um pouco novo para a linguagem Java, estou tentando me familiarizar com todas as maneiras (ou pelo menos as não-patológicas) em que se pode percorrer uma lista (ou talvez outras coleções) e as vantagens ou desvantagens de cada uma.

Dado um List<E> listobjeto, conheço as seguintes maneiras de percorrer todos os elementos:

Básico para loop (é claro, também existem equivalentes while/ do whileloops)

// Not recommended (see below)!
for (int i = 0; i < list.size(); i++) {
    E element = list.get(i);
    // 1 - can call methods of element
    // 2 - can use 'i' to make index-based calls to methods of list

    // ...
}

Nota: Como o @amarseillan apontou, este formulário é uma má escolha para iterar sobre Lists, porque a implementação real do getmétodo pode não ser tão eficiente quanto ao usar um Iterator. Por exemplo, as LinkedListimplementações devem atravessar todos os elementos anteriores a i para obter o i-ésimo elemento.

No exemplo acima, não há como a Listimplementação "salvar seu lugar" para tornar as iterações futuras mais eficientes. Para um ArrayList, isso realmente não importa, porque a complexidade / custo de geté tempo constante (O (1)), enquanto para a LinkedListé proporcional ao tamanho da lista (O (n)).

Para obter mais informações sobre a complexidade computacional das Collectionsimplementações internas, consulte esta pergunta .

Aprimorado para loop (explicado detalhadamente nesta pergunta )

for (E element : list) {
    // 1 - can call methods of element

    // ...
}

Iterador

for (Iterator<E> iter = list.iterator(); iter.hasNext(); ) {
    E element = iter.next();
    // 1 - can call methods of element
    // 2 - can use iter.remove() to remove the current element from the list

    // ...
}

ListIterator

for (ListIterator<E> iter = list.listIterator(); iter.hasNext(); ) {
    E element = iter.next();
    // 1 - can call methods of element
    // 2 - can use iter.remove() to remove the current element from the list
    // 3 - can use iter.add(...) to insert a new element into the list
    //     between element and iter->next()
    // 4 - can use iter.set(...) to replace the current element

    // ...
}

Java funcional

list.stream().map(e -> e + 1); // Can apply a transformation function for e

Iterable.forEach , Stream.forEach , ...

(Um método de mapa da API Stream do Java 8 (consulte a resposta de @i_am_zero).)

No Java 8, as classes de coleção que implementam Iterable(por exemplo, todos os Lists) agora têm um forEachmétodo, que pode ser usado em vez da instrução de loop for demonstrada acima. (Aqui está outra pergunta que fornece uma boa comparação.)

Arrays.asList(1,2,3,4).forEach(System.out::println);
// 1 - can call methods of an element
// 2 - would need reference to containing object to remove an item
//     (TODO: someone please confirm / deny this)
// 3 - functionally separates iteration from the action
//     being performed with each item.

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
// Same capabilities as above plus potentially greater
// utilization of parallelism
// (caution: consequently, order of execution is not guaranteed,
// see [Stream.forEachOrdered][stream-foreach-ordered] for more
// information about this).

Que outras maneiras existem, se houver?

(BTW, meu interesse não resulta de um desejo de otimizar o desempenho ; eu só quero saber quais formulários estão disponíveis para mim como desenvolvedor.)

As três formas de loop são quase idênticas. O forloop aprimorado :

for (E element : list) {
    . . .
}

é, de acordo com a Java Language Specification , idêntico ao uso explícito de um iterador com um forloop tradicional . No terceiro caso, você só pode modificar o conteúdo da lista removendo o elemento atual e, somente se o fizer através do removemétodo do iterador. Com a iteração baseada em índice, você pode modificar a lista de qualquer maneira. No entanto, adicionar ou remover elementos anteriores ao índice atual corre o risco de o loop ignorar elementos ou processar o mesmo elemento várias vezes; você precisa ajustar o índice do loop corretamente quando fizer essas alterações.

Em todos os casos, elementé uma referência ao elemento da lista real. Nenhum dos métodos de iteração faz uma cópia de qualquer coisa na lista. As alterações no estado interno de elementsempre serão vistas no estado interno do elemento correspondente na lista.

Essencialmente, existem apenas duas maneiras de iterar em uma lista: usando um índice ou um iterador. O loop for aprimorado é apenas um atalho sintático introduzido no Java 5 para evitar o tédio de definir explicitamente um iterador. Para ambos os estilos, você pode criar variações essencialmente triviais usando for, whileou do whileblocos, mas todas se resumem à mesma coisa (ou melhor, duas coisas).

EDIT: Como o @ iX3 aponta em um comentário, você pode usar a ListIteratorpara definir o elemento atual de uma lista enquanto estiver iterando. Você precisaria usar em List#listIterator()vez de List#iterator()inicializar a variável de loop (que, obviamente, teria que ser declarada um em ListIteratorvez de um Iterator).

Exemplo de cada tipo listado na pergunta:

ListIterationExample.java

import java.util.*;

public class ListIterationExample {

     public static void main(String []args){
        List<Integer> numbers = new ArrayList<Integer>();

        // populates list with initial values
        for (Integer i : Arrays.asList(0,1,2,3,4,5,6,7))
            numbers.add(i);
        printList(numbers);         // 0,1,2,3,4,5,6,7

        // replaces each element with twice its value
        for (int index=0; index < numbers.size(); index++) {
            numbers.set(index, numbers.get(index)*2); 
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // does nothing because list is not being changed
        for (Integer number : numbers) {
            number++; // number = new Integer(number+1);
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14  

        // same as above -- just different syntax
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            number++;
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // ListIterator<?> provides an "add" method to insert elements
        // between the current element and the cursor
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.add(number+1);     // insert a number right before this
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15

        // Iterator<?> provides a "remove" method to delete elements
        // between the current element and the cursor
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            if (number % 2 == 0)    // if number is even 
                iter.remove();      // remove it from the collection
        }
        printList(numbers);         // 1,3,5,7,9,11,13,15

        // ListIterator<?> provides a "set" method to replace elements
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.set(number/2);     // divide each element by 2
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7
     }

     public static void printList(List<Integer> numbers) {
        StringBuilder sb = new StringBuilder();
        for (Integer number : numbers) {
            sb.append(number);
            sb.append(",");
        }
        sb.deleteCharAt(sb.length()-1); // remove trailing comma
        System.out.println(sb.toString());
     }
}

O loop básico não é recomendado, pois você não conhece a implementação da lista.

Se fosse um LinkedList, cada chamada para

list.get(i)

estaria iterando sobre a lista, resultando em complexidade de tempo N ^ 2.

Uma iteração no estilo JDK8:

public class IterationDemo {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        list.stream().forEach(elem -> System.out.println("element " + elem));
    }
}

No Java 8 , temos várias maneiras de iterar sobre as classes de coleção.

Usando o Iterable forEach

As coleções que implementam Iterable(por exemplo, todas as listas) agora têm forEachmétodo. Podemos usar a referência de método introduzida no Java 8.

Arrays.asList(1,2,3,4).forEach(System.out::println);

Usando Streams forEach e forEachOrdered

Também podemos iterar sobre uma lista usando o Stream como:

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
Arrays.asList(1,2,3,4).stream().forEachOrdered(System.out::println);

Deveríamos preferir o forEachOrderedcontrário, forEachporque o comportamento de forEaché explicitamente não determinístico, onde, como ele forEachOrderedexecuta uma ação para cada elemento desse fluxo, na ordem de encontro do fluxo, se o fluxo tiver uma ordem de encontro definida. Portanto, o forEach não garante que o pedido seja mantido.

A vantagem dos fluxos é que também podemos usar fluxos paralelos sempre que apropriado. Se o objetivo é apenas imprimir os itens, independentemente da ordem, podemos usar o fluxo paralelo como:

Arrays.asList(1,2,3,4).parallelStream().forEach(System.out::println);

Não sei o que você considera patológico, mas deixe-me fornecer algumas alternativas que você nunca viu antes:

List<E> sl= list ;
while( ! sl.empty() ) {
    E element= sl.get(0) ;
    .....
    sl= sl.subList(1,sl.size());
}

Ou sua versão recursiva:

void visit(List<E> list) {
    if( list.isEmpty() ) return;
    E element= list.get(0) ;
    ....
    visit(list.subList(1,list.size()));
}

Além disso, uma versão recursiva do clássico for(int i=0...:

void visit(List<E> list,int pos) {
    if( pos >= list.size() ) return;
    E element= list.get(pos) ;
    ....
    visit(list,pos+1);
}

Eu os mencionei porque você é "um pouco novo em Java" e isso pode ser interessante.

Você pode usar o forEach a partir do Java 8:

 List<String> nameList   = new ArrayList<>(
            Arrays.asList("USA", "USSR", "UK"));

 nameList.forEach((v) -> System.out.println(v));

Para uma pesquisa reversa, você deve usar o seguinte:

for (ListIterator<SomeClass> iterator = list.listIterator(list.size()); iterator.hasPrevious();) {
    SomeClass item = iterator.previous();
    ...
    item.remove(); // For instance.
}

Se você deseja conhecer uma posição, use iterator.previousIndex (). Também ajuda a escrever um loop interno que compara duas posições na lista (os iteradores não são iguais).

Certo, muitas alternativas estão listadas. O mais fácil e limpo seria usar apenas a fordeclaração aprimorada , conforme abaixo. O Expressioné de algum tipo que é iterável.

for ( FormalParameter : Expression ) Statement

Por exemplo, para iterar por meio de List <String> ids, podemos simplesmente fazer isso,

for (String str : ids) {
    // Do something
}

Em java 8você pode usar o List.forEach()método com lambda expressionpara iterar sobre uma lista.

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

public class TestA {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Apple");
        list.add("Orange");
        list.add("Banana");
        list.forEach(
                (name) -> {
                    System.out.println(name);
                }
        );
    }
}

Você sempre pode alternar o primeiro e o terceiro exemplos com um loop while e um pouco mais de código. Isso oferece a vantagem de poder usar o tempo de ação:

int i = 0;
do{
 E element = list.get(i);
 i++;
}
while (i < list.size());

Obviamente, esse tipo de coisa pode causar uma NullPointerException se o list.size () retornar 0, pois sempre é executado pelo menos uma vez. Isso pode ser corrigido testando se o elemento é nulo antes de usar seus atributos / métodos. Ainda assim, é muito mais simples e fácil usar o loop for