Modi per scorrere su un elenco in Java

Essendo un po 'nuovo nel linguaggio Java, sto cercando di familiarizzare con tutti i modi (o almeno quelli non patologici) che uno potrebbe scorrere attraverso un elenco (o forse altre raccolte) e i vantaggi o gli svantaggi di ciascuno.

Dato un List<E> listoggetto, conosco i seguenti modi per scorrere tutti gli elementi:

Basic per loop (ovviamente, ci sono anche equivalenti while/ do whileloop)

// 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: Come sottolineato da @amarseillan, questo modulo è una scelta sbagliata per iterare su Lists, poiché l'implementazione effettiva del getmetodo potrebbe non essere efficiente come quando si usa un Iterator. Ad esempio, le LinkedListimplementazioni devono attraversare tutti gli elementi che precedono i per ottenere l'i-esimo elemento.

Nell'esempio sopra non è possibile che l' Listimplementazione "salvi il suo posto" per rendere le iterazioni future più efficienti. Per un ArrayListnon importa, perché la complessità / costo di getè tempo costante (O (1)) mentre per a LinkedListè proporzionale alla dimensione della lista (O (n)).

Per ulteriori informazioni sulla complessità computazionale delle Collectionsimplementazioni integrate , consulta questa domanda .

Migliorato per il ciclo (ben spiegato in questa domanda )

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

    // ...
}

Iterator

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 funzionale

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

Iterable.forEach , Stream.forEach , ...

(Un metodo cartografico dall'API Stream di Java 8 (vedi la risposta di @ i_am_zero).)

In Java 8 le classi di raccolta che implementano Iterable(per esempio, tutte le Lists) ora hanno un forEachmetodo, che può essere usato al posto dell'istruzione for loop mostrata sopra. (Ecco un'altra domanda che fornisce un buon confronto.)

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).

Quali altri modi ci sono, se ce ne sono?

(A proposito, il mio interesse non deriva affatto dal desiderio di ottimizzare le prestazioni ; voglio solo sapere quali moduli sono disponibili per me come sviluppatore.)

Le tre forme di loop sono quasi identiche. Il forciclo avanzato :

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

è, secondo la specifica del linguaggio Java , identico in effetti all'uso esplicito di un iteratore con un forciclo tradizionale . Nel terzo caso, è possibile modificare il contenuto dell'elenco solo rimuovendo l'elemento corrente e, quindi, solo se lo si fa attraverso il removemetodo dell'iteratore stesso. Con l'iterazione basata su indice, sei libero di modificare l'elenco in qualsiasi modo. Tuttavia, l'aggiunta o la rimozione di elementi che precedono l'indice corrente rischia che il ciclo salti gli elementi o elabori lo stesso elemento più volte; è necessario regolare correttamente l'indice del loop quando si apportano tali modifiche.

In tutti i casi, elementè un riferimento all'elemento elenco effettivo. Nessuno dei metodi di iterazione crea una copia di qualsiasi cosa nell'elenco. Le modifiche allo stato interno di elementsaranno sempre visualizzate nello stato interno dell'elemento corrispondente nell'elenco.

In sostanza, ci sono solo due modi per scorrere su un elenco: usando un indice o usando un iteratore. Il loop for avanzato è solo un collegamento sintattico introdotto in Java 5 per evitare il tedio di definire esplicitamente un iteratore. Per entrambi gli stili, si può trovare con variazioni essenzialmente banali usando for, whileo do whileblocchi, ma tutte si riducono alla stessa cosa (o, meglio, due cose).

EDIT: Come sottolinea @ iX3 in un commento, puoi usare a ListIteratorper impostare l'elemento corrente di un elenco mentre stai ripetendo. Dovresti usare List#listIterator()invece di List#iterator()inizializzare la variabile loop (che, ovviamente, dovrebbe essere dichiarata ListIteratorpiuttosto che una Iterator).

Esempio di ogni tipo elencato nella domanda:

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

Il ciclo di base non è raccomandato in quanto non si conosce l'implementazione dell'elenco.

Se quella era una LinkedList, ogni chiamata a

list.get(i)

verrebbe ripetuto sull'elenco, con conseguente complessità temporale N ^ 2.

Un'iterazione in stile 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));
    }
}

In Java 8 abbiamo diversi modi per scorrere le classi di raccolta.

Utilizzo di Iterable forOach

Le raccolte che implementano Iterable(ad esempio tutte le liste) ora hanno il forEachmetodo. Possiamo usare il metodo di riferimento introdotto in Java 8.

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

Utilizzo di stream per ogni e per ogni ordine

Possiamo anche scorrere su un elenco usando Stream come:

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

Dovremmo preferire forEachOrderedrispetto forEachperché il comportamento di forEachè esplicitamente non deterministico dove come forEachOrderedesegue un'azione per ogni elemento di questo flusso, nell'ordine di incontro del flusso se il flusso ha un ordine di incontro definito. Quindi, Ciascuno non garantisce che l'ordine verrà mantenuto.

Il vantaggio con i flussi è che possiamo anche usare i flussi paralleli dove appropriato. Se l'obiettivo è solo quello di stampare gli articoli indipendentemente dall'ordine, allora possiamo usare il flusso parallelo come:

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

Non so cosa consideri patologico, ma lasciami fornire alcune alternative che non avresti mai visto prima:

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

O la sua versione ricorsiva:

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

Inoltre, una versione ricorsiva del classico 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);
}

Le menziono perché sei "un po 'nuovo di Java" e questo potrebbe essere interessante.

Puoi usare forOach a partire da Java 8:

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

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

Per una ricerca all'indietro è necessario utilizzare quanto segue:

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

Se vuoi conoscere una posizione, usa iterator.previousIndex (). Aiuta anche a scrivere un ciclo interno che confronta due posizioni nell'elenco (gli iteratori non sono uguali).

Bene, sono elencate molte alternative. Il più semplice e pulito sarebbe semplicemente usare l' foristruzione avanzata come di seguito. Il Expressionè di un certo tipo che è iterabile.

for ( FormalParameter : Expression ) Statement

Ad esempio, per scorrere tra gli ID elenco <String>, possiamo semplicemente

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

In java 8puoi usare il List.forEach()metodo con lambda expressionper scorrere su un elenco.

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

Puoi sempre cambiare il primo e il terzo esempio con un ciclo while e un po 'più di codice. Questo ti dà il vantaggio di poter usare il do-while:

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

Naturalmente, questo genere di cose potrebbe causare una NullPointerException se list.size () restituisce 0, poiché viene sempre eseguito almeno una volta. Questo può essere risolto testando se l'elemento è nullo prima di usare i suoi attributi / metodi. Tuttavia, è molto più semplice e facile usare il ciclo for