Les listes en Java nous permettent de maintenir une collection ordonnée d'objets. Les éléments en double ainsi que les éléments nuls peuvent également être stockés dans une liste en Java. L'interface List fait partie de java.util package et il hérite de l’interface Collection. Il préserve l’ordre d’insertion.
Il existe plusieurs façons de parcourir List en Java. Ils sont discutés ci-dessous :
Méthodes :
- Utiliser des boucles (approche naïve)
- En utilisant Itérateur
- En utilisant Itérateur de liste
- Utiliser l'expression lambda
- En utilisant flux.forEach()
- Utilisation de Spliterator (Java 8 et versions ultérieures)
Méthode 1-A : boucle for simple
Chaque élément est accessible par itération à l’aide d’une simple boucle for. L'index est accessible en utilisant l'index comme variable de boucle.
Syntaxe:
for (i = 0; i>
Ci-dessous un exemple de cette méthode :
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 ListmaListe = nouvelle ArrayList(); // Ajout d'éléments à la liste // Entrées personnalisées myList.add('A'); maListe.add('B'); maListe.add('C'); maListe.add('D'); // Boucle For pour parcourir la liste for (int i = 0; i< myList.size(); i++) { // Print all elements of List System.out.println(myList.get(i)); } } }> Sortir
A B C D>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(n), où « n » est la taille de la liste.
Espace auxiliaire : O(1), l'espace constant est utilisé pour les variables de boucle (i dans ce cas).
Méthode 1-B : boucle for améliorée
Chaque élément est accessible par itération à l'aide d'une boucle for améliorée. Cette boucle a été introduite dans J2SE 5.0. C'est une approche alternative pour parcourir la boucle for. Cela rend le code plus lisible.
Syntaxe:
for(data_type variable : List_name) { // Body of the loop. // Each element can be accessed using variable. }>Ci-dessous l'exemple de cette méthode :
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 ListmaListe = nouvelle ArrayList(); // Ajout d'éléments à la liste // Entrées personnalisées myList.add('A'); maListe.add('B'); maListe.add('C'); maListe.add('D'); // Utilisation de la boucle for améliorée (for-each) pour l'itération for (String i : myList) { // Imprimer tous les éléments d'ArrayList System.out.println(i); } } }> Sortir
A B C D>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(n), où « n » est la taille de la liste.
Espace auxiliaire : O(1), l'espace constant est utilisé pour les variables de boucle (i dans ce cas).
Méthode 1-C : utilisation d'une boucle while
Itérer sur une liste peut également être réalisé à l’aide d’une boucle while. Le bloc de code à l'intérieur de la boucle s'exécute jusqu'à ce que la condition soit vraie. Une variable de boucle peut être utilisée comme un index pour accéder à chaque élément.
Syntaxe:
while(variable>
Ci-dessous l'exemple de cette méthode :
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 ListmaListe = nouvelle ArrayList(); // Ajout d'éléments à la liste // Entrées personnalisées myList.add('A'); maListe.add('B'); maListe.add('C'); maListe.add('D'); // Initialisation de n'importe quelle variable à 0 int i = 0; // Si la valeur de la variable est inférieure à // valeur indiquant la taille de la liste tandis que (i< myList.size()) { // Print element of list System.out.println(myList.get(i)); // Increase variable count by 1 i++; } } }> Sortir
A B C D>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(n), où « n » est la taille de la liste.
Espace auxiliaire : O(1), l'espace constant est utilisé pour les variables de boucle (i dans ce cas).
Méthode 2 : utilisation de l'itérateur
Un itérateur est un objet en Java qui permet d'itérer sur les éléments d'une collection. Chaque élément de la liste est accessible à l'aide d'un itérateur avec une boucle while.
opérateurs javascript
Syntaxe:
Iterator variable = list_name.iterator();>
Ci-dessous l'exemple de cette méthode :
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 ListmaListe = nouvelle ArrayList(); // Ajout d'éléments à la liste // Entrées personnalisées myList.add('A'); maListe.add('B'); maListe.add('C'); maListe.add('D'); // Itérateur Itérateurit = maListe.iterator(); // Vérification de condition pour les éléments de la liste // utilisant la méthode hasNext() renvoyant vrai jusqu'à // qu'il y ait un seul élément dans une liste while (it.hasNext()) { // Imprime tous les éléments de la liste System.out.println(it .suivant()); } } }> Sortir
A B C D>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(n), où « n » est la taille de la liste.
Espace auxiliaire : O(1), l'espace constant est utilisé pour les variables de boucle (i dans ce cas).
Méthode 3 : utilisation de l'itérateur de liste
ListIterator est un itérateur en Java disponible depuis la version 1.2. Cela nous permet d'itérer les éléments un par un à partir d'un objet implémenté par List. Il est utilisé pour parcourir une liste en utilisant la boucle while.
Syntaxe:
ListIterator variable = list_name.listIterator();>
Ci-dessous l'exemple de cette méthode :
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 ListmaListe = nouvelle ArrayList(); // Ajout d'éléments à la liste // Entrées personnalisées myList.add('A'); maListe.add('B'); maListe.add('C'); maListe.add('D'); // Itérateur de liste ListIteratorit = maListe.listIterator(); // Condition vérifie s'il y a un élément dans List // en utilisant hasNext() qui reste vrai jusqu'à // qu'il y ait un seul élément dans List while (it.hasNext()) { // Imprime tous les éléments de List System.out.println( it.next()); } } }> Sortir
A B C D>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(n), où « n » est la taille de la liste.
Espace auxiliaire : O(1), l'espace constant est utilisé pour les variables de boucle (i dans ce cas).
Méthode 4 : utiliser Iterable.forEach()
Cette fonctionnalité est disponible depuis Java 8. Elle peut également être utilisée pour parcourir une liste. L'itération peut être effectuée en utilisant un expression lambda.
Syntaxe:
list_name.forEach(variable->{//bloc de code})>Ci-dessous l'exemple de cette méthode :
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 ListmaListe = nouvelle ArrayList(); // Ajout d'éléments à la liste // Entrées personnalisées myList.add('A'); maListe.add('B'); maListe.add('C'); maListe.add('D'); // Expression Lambda imprimant tous les éléments d'une liste myList.forEach( (temp) -> { System.out.println(temp); }); } }> Sortir
A B C D>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(n), où « n » est la taille de la liste.
Espace auxiliaire : O(1), l'espace constant est utilisé pour les variables de boucle (i dans ce cas).
Méthode 5 : utilisation de Stream.forEach()
L'ordre de traitement de stream().forEach() n'est pas défini alors que dans le cas de forEach(), il est défini. Les deux peuvent être utilisés pour parcourir une liste.
Syntaxe:
list_name.stream.forEach(variable->{//bloc de code})>Ci-dessous l'exemple de cette méthode :
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 ListmaListe = nouvelle ArrayList(); // Ajout d'éléments à la liste // Entrées personnalisées myList.add('A'); maListe.add('B'); maListe.add('C'); maListe.add('D'); // La méthode stream.forEach() imprime // tous les éléments à l'intérieur d'une liste myList.stream().forEach( (temp) -> System.out.println(temp)); } }> Sortir
A B C D>
Complexité de la méthode ci-dessus :
c tableau de chaînes
Complexité temporelle : O(n), où « n » est la taille de la liste.
Espace auxiliaire : O(1), l'espace constant est utilisé pour les variables de boucle (i dans ce cas).
Méthodes 6 : Utilisation de Spliterator (Java 8 et versions ultérieures)
Java 8 a introduit le Séparateur interface, qui signifie split itérateur. Il fournit un moyen de parcourir les éléments de manière plus conviviale. Un Spliterator peut être obtenu à partir de diverses sources, y compris des collections comme des listes. La méthode forEachRemaining de Spliterator est utilisée pour parcourir tous les éléments restants de manière séquentielle.
Syntaxe:
Spliterator spliterator = myList.spliterator();>
Ci-dessous l'exemple de cette méthode :
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 ListmaListe = Liste.of('A', 'B', 'C','D'); // Utilisation de Spliterator Spliteratorspliterator = maListe.spliterator(); spliterator.forEachRemaining(System.out::println); } }> Sortir
A B C D>
Complexité de la méthode ci-dessus :
Complexité temporelle : O(n), où « n » est la taille de la liste.
Espace auxiliaire : O(log n) ou O(1), (selon les caractéristiques de l'implémentation de Spliterator)