Lister i Java giver os mulighed for at opretholde en ordnet samling af objekter. Duplikerede elementer såvel som null-elementer kan også gemmes i en liste i Java. Listegrænsefladen er en del af java.util pakken, og den arver samlingsgrænsefladen. Det bevarer rækkefølgen af ​​indsættelse.

Der er flere måder at iterere over List i Java. De diskuteres nedenfor:

Metoder:

1. Brug af loops (naiv tilgang)
   • Til sløjfe
   • For hver sløjfe
   • Mens sløjfe
2. Ved brug af Iterator
3. Ved brug af Liste iterator
4. Brug af lambda-udtryk
5. Ved brug af stream.forEach()
6. Brug af Spliterator (Java 8 og nyere)

Metode 1-A: Enkel til loop

Hvert element kan tilgås ved iteration ved hjælp af en simpel for loop. Indekset kan tilgås ved at bruge indekset som en sløjfevariabel.

Syntaks:

for (i = 0; i>

Nedenfor er et eksempel på denne metode:

// 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 = ny ArrayList();  // Tilføjelse af elementer til listen // Custom inputs myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // For loop til iteration over Listen for (int i = 0; i< myList.size(); i++) {  // Print all elements of List  System.out.println(myList.get(i));  }  } }>

A B C D>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n), hvor 'n' er størrelsen på listen.
Hjælpeplads: O(1), Konstant mellemrum bruges til sløjfevariable (i dette tilfælde).

Metode 1-B: Forbedret til loop

Hvert element kan tilgås ved iteration ved hjælp af en forbedret for loop. Denne sløjfe blev introduceret i J2SE 5.0. Det er en alternativ tilgang til at krydse for en sløjfe. Det gør koden mere læsbar.

Syntaks:

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

Nedenfor er eksemplet på denne metode:

// 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 = ny ArrayList();  // Tilføjelse af elementer til listen // Custom inputs myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Bruger enhanced for loop(for-each) til iteration for (String i : myList) { // Udskriv alle elementer i ArrayList System.out.println(i);  } } }>

A B C D>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n), hvor 'n' er størrelsen på listen.
Hjælpeplads: O(1), Konstant mellemrum bruges til sløjfevariable (i i dette tilfælde).

strengformater

Metode 1-C: Brug af en while-løkke

Iteration over en liste kan også opnås ved hjælp af en while-løkke. Kodeblokken inde i løkken udføres, indtil betingelsen er sand. En loop variabel kan bruges som en indeks for at få adgang til hvert element.

Syntaks:

while(variable>

Nedenfor er eksemplet på denne metode:

// 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 = ny ArrayList();  // Tilføjelse af elementer til listen // Custom inputs myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Initialisering af enhver variabel til 0 int i = 0;  // Hvis variabelværdien er mindre end // værdien angiver størrelsen af ​​Listen mens (dvs< myList.size()) {  // Print element of list  System.out.println(myList.get(i));  // Increase variable count by 1  i++;  }  } }>

A B C D>

Kompleksiteten af ​​ovenstående metode:

ækvivalens love

Tidskompleksitet: O(n), hvor 'n' er størrelsen på listen.
Hjælpeplads : O(1), Konstant mellemrum bruges til sløjfevariable (i i dette tilfælde).

Metode 2: Brug af iterator

En iterator er et objekt i Java, der tillader iteration over elementer i en samling. Hvert element på listen kan tilgås ved hjælp af iterator med en while-løkke.

Syntaks:

Iterator variable = list_name.iterator();>

Nedenfor er eksemplet på denne metode:

// 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 = ny ArrayList();  // Tilføjelse af elementer til listen // Custom inputs myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Iterator Iteratorit = myList.iterator();  // Tilstandstjek for elementer i List // ved hjælp af hasNext() metoden returnerer true indtil // der er et enkelt element i en List while (it.hasNext()) { // Udskriv alle elementer af List System.out.println(it) .Næste());  } } }>

A B C D>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n), hvor 'n' er størrelsen på listen.
Hjælpeplads: O(1), Konstant mellemrum bruges til sløjfevariable (i i dette tilfælde).

Metode 3: Brug af List iterator

ListIterator er en iterator i Java, som er tilgængelig siden 1.2-versionen. Det giver os mulighed for at iterere elementer én for én fra et List-implementeret objekt. Det bruges til at iterere over en liste ved hjælp af while-løkke.

Syntaks:

ListIterator variable = list_name.listIterator();>

Nedenfor er eksemplet på denne metode:

// 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 = ny ArrayList();  // Tilføjelse af elementer til listen // Custom inputs myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // List iterator ListIteratorit = myList.listIterator();  // Betingelsestjek om der er element i List // ved hjælp af hasNext() som gælder indtil // der er et enkelt element i List while (it.hasNext()) { // Udskriv alle elementer af List System.out.println( it.next());  } } }>

A B C D>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n), hvor 'n' er størrelsen på listen.
Hjælpeplads: O(1), Konstant mellemrum bruges til sløjfevariable (i i dette tilfælde).

Metode 4: Brug af Iterable.forEach()

Denne funktion er tilgængelig siden Java 8. Den kan også bruges til at iterere over en liste. Iteration kan udføres vha -en lambda udtryk.

Syntaks:

list_name.forEach(variable->{//kodeblok})>

Nedenfor er eksemplet på denne metode:

// 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 = ny ArrayList();  // Tilføjelse af elementer til listen // Custom inputs myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // Lambda-udtryk, der udskriver alle elementer i en Liste myList.forEach( (temp) -> { System.out.println(temp); });  } }>

A B C D>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n), hvor 'n' er størrelsen på listen.
Hjælpeplads: O(1), Konstant mellemrum bruges til sløjfevariable (i i dette tilfælde).

Metode 5: Brug af Stream.forEach()

Behandlingsrækkefølgen for stream().forEach() er udefineret, mens den i tilfælde af forEach() er defineret. Begge kan bruges til at iterere over en liste.

Syntaks:

list_name.stream.forEach(variable->{//kodeblok})>

Nedenfor er eksemplet på denne metode:

// 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 = ny ArrayList();  // Tilføjelse af elementer til listen // Custom inputs myList.add('A');  myList.add('B');  myList.add('C');  myList.add('D');  // stream.forEach() metoden udskriver // alle elementer inde i en List myList.stream().forEach( (temp) -> System.out.println(temp));  } }>

A B C D>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n), hvor 'n' er størrelsen på listen.
Hjælpeplads: O(1), Konstant mellemrum bruges til sløjfevariable (i dette tilfælde).

Metoder 6: Brug af Spliterator (Java 8 og nyere)

Java 8 introducerede Spliterator interface, som står for split iterator. Det giver en måde at iterere over elementer på en mere parallelvenlig måde. En Spliterator kan fås fra forskellige kilder, herunder samlinger som lister. ForEachRemaining-metoden i Spliterator bruges til at krydse alle resterende elementer sekventielt.

Syntaks:

Spliterator spliterator = myList.spliterator();>

Nedenfor er eksemplet på denne metode:

centerbillede i css

// 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  ListmyList = List.of('A', 'B', 'C','D');    // Brug af Spliterator Spliteratorsplitter = minList.spliterator();  spliterator.forEachRemaining(System.out::println);  } }>

A B C D>

Kompleksiteten af ​​ovenstående metode:

Tidskompleksitet: O(n), hvor 'n' er størrelsen på listen.
Hjælpeplads: O(log n) eller O(1), (afhængigt af karakteristikaene for Spliterator-implementeringen)