Gli elenchi in Java ci consentono di mantenere una raccolta ordinata di oggetti. Anche gli elementi duplicati e gli elementi nulli possono essere archiviati in un elenco in Java. L'interfaccia Elenco è una parte di java.util pacchetto ed eredita l'interfaccia Collection. Conserva l'ordine di inserimento.

Esistono diversi modi per scorrere List in Java. Sono discussi di seguito:

Metodi:

1. Utilizzo dei loop (approccio ingenuo)
   • Per ciclo
   • Per ogni ciclo
   • Mentre il ciclo
2. Utilizzando Iteratore
3. Utilizzando Iteratore elenco
4. Utilizzando l'espressione lambda
5. Utilizzando stream.forEach()
6. Utilizzo di Spliterator (Java 8 e versioni successive)

Metodo 1-A: semplice ciclo for

È possibile accedere a ciascun elemento tramite iterazione utilizzando un semplice ciclo for. È possibile accedere all'indice utilizzando l'indice come variabile di ciclo.

Sintassi:

for (i = 0; i>

Di seguito è riportato un esempio di questo metodo:

// Java Program to iterate over List // Using simple for loop // Importing all classes of // java.util package import java.util.*; // CLass class GFG {  // Main driver method  public static void main(String args[])  {  // Creating a ArrayList  ListmyList = nuova ArrayList();  // Aggiunta di elementi all'elenco // Ingressi personalizzati myList.add('A');  miaLista.add('B');  miaLista.add('C');  miaLista.add('D');  // Ciclo For per eseguire iterazioni sulla Lista for (int i = 0; i< myList.size(); i++) {  // Print all elements of List  System.out.println(myList.get(i));  }  } }>

A B C D>

Complessità del metodo di cui sopra:

fine Java

Complessità temporale: O(n), dove 'n' è la dimensione dell'elenco.
Spazio ausiliario: O(1), lo spazio costante viene utilizzato per le variabili del ciclo (i in questo caso).

Metodo 1-B: ciclo for migliorato

È possibile accedere a ciascun elemento tramite iterazione utilizzando un ciclo for avanzato. Questo ciclo è stato introdotto in J2SE 5.0. È un approccio alternativo per attraversare il ciclo for. Rende il codice più leggibile.

Sintassi:

for(data_type variable : List_name) { // Body of the loop. // Each element can be accessed using variable. }>

Di seguito è riportato l'esempio di questo metodo:

// Java Program to Iterate over a List // using enhanced for loop (for-each) // Importing all classes of // java.util package import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist  ListmyList = nuova ArrayList();  // Aggiunta di elementi all'elenco // Ingressi personalizzati myList.add('A');  miaLista.add('B');  miaLista.add('C');  miaLista.add('D');  // Utilizzo del ciclo for avanzato(for-each) per l'iterazione for (String i: myList) { // Stampa tutti gli elementi di ArrayList System.out.println(i);  } } }>

A B C D>

Complessità del metodo di cui sopra:

Complessità temporale: O(n), dove 'n' è la dimensione dell'elenco.
Spazio ausiliario: O(1), lo spazio costante viene utilizzato per le variabili del ciclo (i in questo caso).

Metodo 1-C: utilizzo di un ciclo while

L'iterazione su un elenco può essere ottenuta anche utilizzando un ciclo while. Il blocco di codice all'interno del ciclo viene eseguito finché la condizione non diventa vera. Una variabile di ciclo può essere utilizzata come UN indice per accedere a ciascun elemento.

Sintassi:

while(variable>

Di seguito è riportato l'esempio di questo metodo:

// Java Program to iterate over a List // using while loop // Importing all classes of // java.util package import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = nuova ArrayList();  // Aggiunta di elementi all'elenco // Ingressi personalizzati myList.add('A');  miaLista.add('B');  miaLista.add('C');  miaLista.add('D');  // Inizializza qualsiasi variabile su 0 int i = 0;  // Se il valore della variabile è inferiore // al valore che indica la dimensione della Lista mentre (i< myList.size()) {  // Print element of list  System.out.println(myList.get(i));  // Increase variable count by 1  i++;  }  } }>

A B C D>

Complessità del metodo di cui sopra:

Complessità temporale: O(n), dove 'n' è la dimensione dell'elenco.
Spazio ausiliario : O(1), lo spazio costante viene utilizzato per le variabili del ciclo (i in questo caso).

Metodo 2: utilizzo dell'iteratore

Un iteratore è un oggetto in Java che consente di eseguire iterazioni sugli elementi di una raccolta. È possibile accedere a ciascun elemento nell'elenco utilizzando l'iteratore con un ciclo while.

set vs mappa

Sintassi:

Iterator variable = list_name.iterator();>

Di seguito è riportato l'esempio di questo metodo:

// Java Program to iterate over the list // using iterator // Importing all classes of // java.util package import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = nuova ArrayList();  // Aggiunta di elementi all'elenco // Ingressi personalizzati myList.add('A');  miaLista.add('B');  miaLista.add('C');  miaLista.add('D');  // Iteratore Iteratoreit = miaLista.iterator();  // Verifica le condizioni per gli elementi in List // utilizzando il metodo hasNext() che restituisce true finché // c'è un singolo elemento in un List while (it.hasNext()) { // Stampa tutti gli elementi di List System.out.println(it .Prossimo());  } } }>

A B C D>

Complessità del metodo di cui sopra:

Complessità temporale: O(n), dove 'n' è la dimensione dell'elenco.
Spazio ausiliario: O(1), lo spazio costante viene utilizzato per le variabili del ciclo (i in questo caso).

Metodo 3: utilizzo dell'iteratore Elenco

ListIterator è un iteratore in Java disponibile a partire dalla versione 1.2. Ci consente di ripetere gli elementi uno per uno da un oggetto implementato List. Viene utilizzato per iterare su un elenco utilizzando il ciclo while.

Sintassi:

ListIterator variable = list_name.listIterator();>

Di seguito è riportato l'esempio di questo metodo:

// Java program to iterate over a list // using ListIterator import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = nuova ArrayList();  // Aggiunta di elementi all'elenco // Ingressi personalizzati myList.add('A');  miaLista.add('B');  miaLista.add('C');  miaLista.add('D');  // Iteratore elenco ListIteratorit = miaLista.listIterator();  // La condizione controlla se c'è un elemento in List // usando hasNext() che rimane vero finché // c'è un singolo elemento in List while (it.hasNext()) { // Stampa tutti gli elementi di List System.out.println( it.successivo());  } } }>

A B C D>

Complessità del metodo di cui sopra:

Complessità temporale: O(n), dove 'n' è la dimensione dell'elenco.
Spazio ausiliario: O(1), lo spazio costante viene utilizzato per le variabili del ciclo (i in questo caso).

Metodo 4: utilizzo di Iterable.forEach()

Questa funzionalità è disponibile a partire da Java 8. Può anche essere utilizzata per scorrere un elenco. L'iterazione può essere eseguita utilizzando UN espressione lambda.

Sintassi:

list_name.forEach(variable->{//blocco di codice})>

Di seguito è riportato l'esempio di questo metodo:

// Java Program to iterate over a List // using forEach() // Importing all classes of // java.util method import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = nuova ArrayList();  // Aggiunta di elementi all'elenco // Ingressi personalizzati myList.add('A');  miaLista.add('B');  miaLista.add('C');  miaLista.add('D');  // Espressione lambda che stampa tutti gli elementi in una lista myList.forEach( (temp) -> { System.out.println(temp); });  } }>

A B C D>

Complessità del metodo di cui sopra:

Complessità temporale: O(n), dove 'n' è la dimensione dell'elenco.
Spazio ausiliario: O(1), lo spazio costante viene utilizzato per le variabili del ciclo (i in questo caso).

Metodo 5: utilizzo di Stream.forEach()

L'ordine di elaborazione di stream().forEach() non è definito mentre nel caso di forEach() è definito. Entrambi possono essere utilizzati per scorrere un elenco.

pagine del server Java

Sintassi:

list_name.stream.forEach(variable->{//blocco di codice})>

Di seguito è riportato l'esempio di questo metodo:

// Java Program iterating over a List // using stream.forEach() method // Importing all classes of // java.util method import java.util.*; // Class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an ArrayList  ListmyList = nuova ArrayList();  // Aggiunta di elementi all'elenco // Ingressi personalizzati myList.add('A');  miaLista.add('B');  miaLista.add('C');  miaLista.add('D');  // Il metodo stream.forEach() stampa // tutti gli elementi all'interno di una Lista myList.stream().forEach( (temp) -> System.out.println(temp));  } }>

A B C D>

Complessità del metodo di cui sopra:

Complessità temporale: O(n), dove 'n' è la dimensione dell'elenco.
Spazio ausiliario: O(1), lo spazio costante viene utilizzato per le variabili del ciclo (i in questo caso).

Metodi 6: utilizzo di Spliterator (Java 8 e versioni successive)

Java 8 ha introdotto il Spliteratore interfaccia, che sta per split iterator. Fornisce un modo per scorrere gli elementi in modo più intuitivo. Uno Spliterator può essere ottenuto da varie fonti, incluse raccolte come elenchi. Il metodo forEachRemaining di Spliterator viene utilizzato per attraversare tutti gli elementi rimanenti in sequenza.

Sintassi:

Spliterator spliterator = myList.spliterator();>

Di seguito è riportato l'esempio di questo metodo:

// Java Program iterating over a List // using Spliterator import java.util.List; import java.util.Spliterator; public class ListIteration {  public static void main(String[] args) {  // List of String  ListmiaLista = Lista.di('A', 'B', 'C','D');    // Utilizzo di Spliterator Spliteratorspliterator = miaLista.spliterator();  spliterator.forEachRemaining(System.out::println);  } }>

A B C D>

Complessità del metodo di cui sopra:

Complessità temporale: O(n), dove 'n' è la dimensione dell'elenco.
Spazio ausiliario: O(log n) o O(1), (a seconda delle caratteristiche dell'implementazione dello Spliterator)