Met lijsten in Java kunnen we een geordende verzameling objecten bijhouden. Zowel dubbele elementen als null-elementen kunnen ook in een lijst in Java worden opgeslagen. De Lijst-interface is een onderdeel van java.util pakket en het neemt de Collection-interface over. Het behoudt de volgorde van invoeging.
Er zijn verschillende manieren om List in Java te herhalen. Ze worden hieronder besproken:
Methoden:
- Loops gebruiken (naïeve benadering)
- Gebruik makend van Iterator
- Gebruik makend van Lijst-iterator
- Lambda-expressie gebruiken
- Gebruik makend van stream.forEach()
- Spliterator gebruiken (Java 8 en hoger)
Methode 1-A: Eenvoudig voor lus
Elk element is toegankelijk via iteratie met behulp van een eenvoudige for-lus. De index is toegankelijk door de index als lusvariabele te gebruiken.
Syntaxis:
for (i = 0; i>
Hieronder ziet u een voorbeeld van deze 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 ListmijnLijst = nieuwe ArrayList(); // Elementen aan de lijst toevoegen // Aangepaste invoer myList.add('A'); mijnLijst.add('B'); mijnLijst.add('C'); mijnLijst.add('D'); // For-lus voor het herhalen van de lijst voor (int i = 0; i< myList.size(); i++) { // Print all elements of List System.out.println(myList.get(i)); } } }> Uitvoer
A B C D>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(n), waarbij ‘n’ de grootte van de lijst is.
Hulpruimte: O(1), Constante ruimte wordt gebruikt voor lusvariabelen (i in dit geval).
Methode 1-B: Verbeterd voor lus
Elk element is toegankelijk via iteratie met behulp van een verbeterde for-lus. Deze lus werd geïntroduceerd in J2SE 5.0. Het is een alternatieve benadering om de for a-lus te doorlopen. Het maakt de code beter leesbaar.
alisa velenonok
Syntaxis:
for(data_type variable : List_name) { // Body of the loop. // Each element can be accessed using variable. }>Hieronder vindt u het voorbeeld van deze 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 ListmijnLijst = nieuwe ArrayList(); // Elementen aan de lijst toevoegen // Aangepaste invoer myList.add('A'); mijnLijst.add('B'); mijnLijst.add('C'); mijnLijst.add('D'); // Verbeterde for loop(for-each) gebruiken voor iteratie voor (String i: myList) {// Druk alle elementen van ArrayList af System.out.println(i); } } }> Uitvoer
A B C D>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(n), waarbij ‘n’ de grootte van de lijst is.
Hulpruimte: O(1), Constante ruimte wordt gebruikt voor lusvariabelen (i in dit geval).
Methode 1-C: Een while-lus gebruiken
Het herhalen van een lijst kan ook worden bereikt met behulp van een while-lus. Het codeblok in de lus wordt uitgevoerd totdat de voorwaarde waar is. Een lusvariabele kan worden gebruikt als een index om toegang te krijgen tot elk element.
Syntaxis:
grijze code
while(variable>
Hieronder vindt u het voorbeeld van deze 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 ListmijnLijst = nieuwe ArrayList(); // Elementen aan de lijst toevoegen // Aangepaste invoer myList.add('A'); mijnLijst.add('B'); mijnLijst.add('C'); mijnLijst.add('D'); // Elke variabele initialiseren naar 0 int i = 0; // Als de variabele waarde kleiner is dan // waarde die de grootte van de lijst aangeeft terwijl (i< myList.size()) { // Print element of list System.out.println(myList.get(i)); // Increase variable count by 1 i++; } } }> Uitvoer
A B C D>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(n), waarbij ‘n’ de grootte van de lijst is.
Hulpruimte : O(1), Constante ruimte wordt gebruikt voor lusvariabelen (i in dit geval).hernoem map op linux
Methode 2: Iterator gebruiken
Een iterator is een object in Java waarmee elementen van een verzameling kunnen worden herhaald. Elk element in de lijst is toegankelijk via een iterator met een while-lus.
Syntaxis:
Iterator variable = list_name.iterator();>
Hieronder vindt u het voorbeeld van deze 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 ListmijnLijst = nieuwe ArrayList(); // Elementen aan de lijst toevoegen // Aangepaste invoer myList.add('A'); mijnLijst.add('B'); mijnLijst.add('C'); mijnLijst.add('D'); // IteratorIteratorit = mijnLijst.iterator(); // Conditiecontrole voor elementen in Lijst // met behulp van de hasNext()-methode die true retourneert tot // er is een enkel element in een Lijst terwijl (it.hasNext()) {// Alle elementen van Lijst afdrukken System.out.println(it .volgende()); } } }> Uitvoer
A B C D>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(n), waarbij ‘n’ de grootte van de lijst is.
Hulpruimte: O(1), Constante ruimte wordt gebruikt voor lusvariabelen (i in dit geval).
Methode 3: Lijstiterator gebruiken
ListIterator is een iterator in Java die beschikbaar is sinds versie 1.2. Het stelt ons in staat elementen één voor één te herhalen uit een in List geïmplementeerd object. Het wordt gebruikt om een lijst te herhalen met behulp van een while-lus.
Syntaxis:
ListIterator variable = list_name.listIterator();>
Hieronder vindt u het voorbeeld van deze 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 ListmijnLijst = nieuwe ArrayList(); // Elementen aan de lijst toevoegen // Aangepaste invoer myList.add('A'); mijnLijst.add('B'); mijnLijst.add('C'); mijnLijst.add('D'); // Lijstiterator LijstIteratorit = mijnList.listIterator(); // Conditiecontrole of er een element in List is // gebruik hasNext() wat waar blijft tot // er is een enkel element in List while (it.hasNext()) {// Druk alle elementen van List af System.out.println( it.volgende()); } } }> Uitvoer
A B C D>
Complexiteit van de bovenstaande methode:
microservices-tutorial
Tijdcomplexiteit: O(n), waarbij ‘n’ de grootte van de lijst is.
Hulpruimte: O(1), Constante ruimte wordt gebruikt voor lusvariabelen (i in dit geval).
Methode 4: Iterable.forEach() gebruiken
Deze functie is beschikbaar sinds Java 8. Het kan ook worden gebruikt om een lijst te herhalen. Iteratie kan worden gedaan met behulp van A lambda-expressie.
Syntaxis:
list_name.forEach(variable->{//codeblok})>Hieronder vindt u het voorbeeld van deze 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 ListmijnLijst = nieuwe ArrayList(); // Elementen aan de lijst toevoegen // Aangepaste invoer myList.add('A'); mijnLijst.add('B'); mijnLijst.add('C'); mijnLijst.add('D'); // Lambda-expressie die alle elementen in een lijst afdrukt myList.forEach( (temp) -> { System.out.println(temp); }); } }> Uitvoer
A B C D>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(n), waarbij ‘n’ de grootte van de lijst is.
Hulpruimte: O(1), Constante ruimte wordt gebruikt voor lusvariabelen (i in dit geval).
Methode 5: Stream.forEach() gebruiken
De verwerkingsvolgorde van stream().forEach() is niet gedefinieerd, terwijl deze in het geval van forEach() wel gedefinieerd is. Beide kunnen worden gebruikt om een lijst te herhalen.
Syntaxis:
sorteer arraylijst java
list_name.stream.forEach(variable->{//codeblok})>Hieronder vindt u het voorbeeld van deze 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 ListmijnLijst = nieuwe ArrayList(); // Elementen aan de lijst toevoegen // Aangepaste invoer myList.add('A'); mijnLijst.add('B'); mijnLijst.add('C'); mijnLijst.add('D'); // stream.forEach() methode drukt // alle elementen in een lijst af myList.stream().forEach( (temp) -> System.out.println(temp)); } }> Uitvoer
A B C D>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(n), waarbij ‘n’ de grootte van de lijst is.
Hulpruimte: O(1), Constante ruimte wordt gebruikt voor lusvariabelen (i in dit geval).
Methoden 6: Spliterator gebruiken (Java 8 en hoger)
Java 8 introduceerde de Splitser interface, wat staat voor split iterator. Het biedt een manier om elementen op een meer parallel-vriendelijke manier te doorlopen. Een Spliterator kan worden verkregen uit verschillende bronnen, waaronder verzamelingen zoals lijsten. De forEachRemaining-methode van Spliterator wordt gebruikt om alle resterende elementen opeenvolgend te doorlopen.
Syntaxis:
Spliterator spliterator = myList.spliterator();>
Hieronder vindt u het voorbeeld van deze 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 ListmijnLijst = Lijst.van('A', 'B', 'C','D'); // Spliterator gebruiken. Spliteratorspliterator = mijnLijst.spliterator(); spliterator.forEachRemaining(System.out::println); } }> Uitvoer
A B C D>
Complexiteit van de bovenstaande methode:
Tijdcomplexiteit: O(n), waarbij ‘n’ de grootte van de lijst is.
Hulpruimte: O(log n) of O(1), (afhankelijk van de kenmerken van de Spliterator-implementatie)