Modi per iterare su un elenco in Java

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 quello era un LinkedList, ogni chiamata a

list.get(i)

Sarebbe l'iterazione sulla lista, 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 iterare sulle classi di raccolta.

Utilizzando forEach iterabile

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

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

Utilizzo dei flussi forEach e forEachOrdered

Possiamo anche iterare 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 forEachOrdered su forEach perché il comportamento di forEach è esplicitamente non deterministico dove come forEachOrdered esegue un'azione per ogni elemento di questo flusso, nell'ordine di incontro del flusso se il flusso ha un ordine di incontro definito. Così forEach non garantisce che l'ordine sarebbe mantenuto.

Il vantaggio con i flussi è che possiamo anche fare uso di flussi paralleli laddove appropriato. Se l'obiettivo è solo quello di stampare gli articoli indipendentemente dall'ordine, possiamo usare parallel stream come:

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

Non lo so cosa consideri patologico, ma lascia che ti fornisca alcune alternative che potresti non aver 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);
}

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

Puoi usare forEach 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 dovresti usare 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).

In java 8 è possibile utilizzare il metodo List.forEach() con lambda expression per iterare 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);
                }
        );
    }
}

Giusto, sono elencate molte alternative. Il più semplice e pulito sarebbe solo usare l'istruzione enhanced for come di seguito. Il Expression è di qualche tipo che è iterabile.

for ( FormalParameter : Expression ) Statement

Ad esempio, per scorrere, List id, possiamo semplicemente così,

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

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 essere in grado di utilizzare il do-while:

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

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