Mit Listen in Java können wir eine geordnete Sammlung von Objekten verwalten. Doppelte Elemente sowie Nullelemente können in Java auch in einer Liste gespeichert werden. Die List-Schnittstelle ist ein Teil von java.util Paket und erbt die Collection-Schnittstelle. Die Reihenfolge der Einfügung bleibt erhalten.
Es gibt mehrere Möglichkeiten, List in Java zu durchlaufen. Sie werden im Folgenden besprochen:
Methoden:
- Verwendung von Schleifen (naiver Ansatz)
- Benutzen Iterator
- Benutzen Listeniterator
- Verwendung des Lambda-Ausdrucks
- Benutzen stream.forEach()
- Verwenden von Spliterator (Java 8 und höher)
Methode 1-A: Einfache for-Schleife
Auf jedes Element kann durch Iteration mit einer einfachen for-Schleife zugegriffen werden. Auf den Index kann zugegriffen werden, indem der Index als Schleifenvariable verwendet wird.
Syntax:
for (i = 0; i>
Nachfolgend finden Sie ein Beispiel für diese Methode:
Java
// 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 = neue ArrayList(); // Elemente zur Liste hinzufügen // Benutzerdefinierte Eingaben myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // For-Schleife zum Durchlaufen der Liste for (int i = 0; i< myList.size(); i++) { // Print all elements of List System.out.println(myList.get(i)); } } }> Ausgabe
A B C D>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(n), wobei „n“ die Größe der Liste ist.
Hilfsraum: O(1), Konstanter Raum wird für Schleifenvariablen verwendet (in diesem Fall i).
Methode 1-B: Erweiterte for-Schleife
Auf jedes Element kann durch Iteration mithilfe einer erweiterten for-Schleife zugegriffen werden. Diese Schleife wurde in J2SE 5.0 eingeführt. Es handelt sich um einen alternativen Ansatz zum Durchlaufen der for-Schleife. Dadurch wird der Code besser lesbar.
Syntax:
Iterieren einer Karte in Java
for(data_type variable : List_name) { // Body of the loop. // Each element can be accessed using variable. }>Nachfolgend finden Sie ein Beispiel für diese Methode:
Java // 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 = neue ArrayList(); // Elemente zur Liste hinzufügen // Benutzerdefinierte Eingaben myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Erweiterte for-Schleife (for-each) für die Iteration verwenden for (String i : myList) { // Alle Elemente von ArrayList drucken System.out.println(i); } } }> Ausgabe
A B C D>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(n), wobei „n“ die Größe der Liste ist.
Hilfsraum: O(1), Konstanter Raum wird für Schleifenvariablen verwendet (in diesem Fall i).iPhone-Emojis auf Android
Methode 1-C: Verwenden einer While-Schleife
Das Durchlaufen einer Liste kann auch mithilfe einer While-Schleife erreicht werden. Der Codeblock innerhalb der Schleife wird ausgeführt, bis die Bedingung wahr ist. Eine Schleifenvariable kann als verwendet werden ein Index, um auf jedes Element zuzugreifen.
Syntax:
while(variable>
Nachfolgend finden Sie ein Beispiel für diese Methode:
Java // 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 = neue ArrayList(); // Elemente zur Liste hinzufügen // Benutzerdefinierte Eingaben myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Initialisierung einer beliebigen Variablen auf 0 int i = 0; // Wenn der Variablenwert kleiner ist als // der Wert, der die Größe der Liste angibt, während (i< myList.size()) { // Print element of list System.out.println(myList.get(i)); // Increase variable count by 1 i++; } } }> Ausgabe
A B C D>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(n), wobei „n“ die Größe der Liste ist.
Hilfsraum : O(1), Konstanter Raum wird für Schleifenvariablen verwendet (in diesem Fall i).
Methode 2: Iterator verwenden
Ein Iterator ist ein Objekt in Java, das die Iteration über Elemente einer Sammlung ermöglicht. Auf jedes Element in der Liste kann mithilfe eines Iterators mit einer While-Schleife zugegriffen werden.
Syntax:
Iterator variable = list_name.iterator();>
Nachfolgend finden Sie ein Beispiel für diese Methode:
Java // 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 = neue ArrayList(); // Elemente zur Liste hinzufügen // Benutzerdefinierte Eingaben myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Iterator Iteratorit = myList.iterator(); // Bedingungsprüfung für Elemente in der Liste // mit der Methode hasNext(), die true zurückgibt, bis // es ein einzelnes Element in einer Liste gibt while (it.hasNext()) { // Alle Elemente der Liste drucken System.out.println(it .nächste()); } } }> Ausgabe
A B C D>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(n), wobei „n“ die Größe der Liste ist.
Hilfsraum: O(1), Konstanter Raum wird für Schleifenvariablen verwendet (in diesem Fall i).
Methode 3: Verwenden des Listeniterators
ListIterator ist ein Iterator in Java, der seit der Version 1.2 verfügbar ist. Es ermöglicht uns, Elemente einzeln aus einem List-implementierten Objekt zu iterieren. Es wird zum Durchlaufen einer Liste mithilfe einer While-Schleife verwendet.
Syntax:
ListIterator variable = list_name.listIterator();>
Nachfolgend finden Sie ein Beispiel für diese Methode:
Java // 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 = neue ArrayList(); // Elemente zur Liste hinzufügen // Benutzerdefinierte Eingaben myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Listeniterator ListIteratorit = myList.listIterator(); // Bedingung prüft, ob es ein Element in der Liste gibt // mit hasNext(), was wahr bleibt, bis // es ein einzelnes Element in der Liste gibt, while (it.hasNext()) { // Alle Elemente der Liste drucken System.out.println( it.next()); } } }> Ausgabe
A B C D>
Komplexität der oben genannten Methode:
Linux welcher Befehl
Zeitkomplexität: O(n), wobei „n“ die Größe der Liste ist.
Hilfsraum: O(1), Konstanter Raum wird für Schleifenvariablen verwendet (in diesem Fall i).
Methode 4: Verwenden von Iterable.forEach()
Diese Funktion ist seit Java 8 verfügbar. Sie kann auch zum Durchlaufen einer Liste verwendet werden. Die Iteration kann mit erfolgen A Lambda-Ausdruck.
Syntax:
list_name.forEach(variable->{//Codeblock})>Nachfolgend finden Sie ein Beispiel für diese Methode:
Java // 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 = neue ArrayList(); // Elemente zur Liste hinzufügen // Benutzerdefinierte Eingaben myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // Lambda-Ausdruck druckt alle Elemente in einer Liste myList.forEach( (temp) -> { System.out.println(temp); }); } }> Ausgabe
A B C D>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(n), wobei „n“ die Größe der Liste ist.
Hilfsraum: O(1), Konstanter Raum wird für Schleifenvariablen verwendet (in diesem Fall i).Java analysiert String in int
Methode 5: Verwenden von Stream.forEach()
Die Verarbeitungsreihenfolge von stream().forEach() ist undefiniert, während sie im Fall von forEach() definiert ist. Beide können zum Durchlaufen einer Liste verwendet werden.
Syntax:
list_name.stream.forEach(variable->{//Codeblock})>Nachfolgend finden Sie ein Beispiel für diese Methode:
Java // 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 = neue ArrayList(); // Elemente zur Liste hinzufügen // Benutzerdefinierte Eingaben myList.add('A'); myList.add('B'); myList.add('C'); myList.add('D'); // stream.forEach()-Methode druckt // alle Elemente innerhalb einer Liste myList.stream().forEach( (temp) -> System.out.println(temp)); } }> Ausgabe
A B C D>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(n), wobei „n“ die Größe der Liste ist.
Hilfsraum: O(1), Konstanter Raum wird für Schleifenvariablen verwendet (in diesem Fall i).
Methoden 6: Verwendung von Spliterator (Java 8 und höher)
Java 8 führte das ein Spliterator Schnittstelle, was für Split Iterator steht. Es bietet eine Möglichkeit, Elemente paralleler zu durchlaufen. Ein Spliterator kann aus verschiedenen Quellen bezogen werden, darunter auch Sammlungen wie Listen. Die forEachRemaining-Methode von Spliterator wird verwendet, um alle verbleibenden Elemente nacheinander zu durchlaufen.
Syntax:
Spliterator spliterator = myList.spliterator();>
Nachfolgend finden Sie ein Beispiel für diese Methode:
Java // 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'); // Spliterator Spliterator verwendenspliterator = myList.spliterator(); spliterator.forEachRemaining(System.out::println); } }> Ausgabe
A B C D>
Komplexität der oben genannten Methode:
Zeitkomplexität: O(n), wobei „n“ die Größe der Liste ist.
Hilfsraum: O(log n) oder O(1), (abhängig von den Eigenschaften der Spliterator-Implementierung)