Moyens d’itérer une liste en Java

Façons d'itérer une liste en Java

1. introduction

Itérer sur les éléments d’une liste est l’une des tâches les plus courantes d’un programme.

Dans ce didacticiel, nous allons passer en revue différentes façons de procéder en Java. Nous allons nous concentrer sur l'itération de la liste dans l'ordre, même si le fait de parcouririn reverse est également simple.

2. Bouclefor

Tout d'abord, passons en revue quelques options defor loop.

Commençons par définir une liste de pays pour nos exemples:

List countries = Arrays.asList("Germany", "Panama", "Australia");

2.1. Boucle de basefor

L'instruction de contrôle de flux la plus courante pour l'itération est la boucle de basefor.

La bouclefor définit trois types d'instructions séparées par des points-virgules. La première déclaration est la déclaration d'initialisation. Le second définit la condition de terminaison. La dernière déclaration est la clause de mise à jour.

Ici, nous utilisons simplement une variable entière comme index:

for (int i = 0; i < countries.size(); i++) {
    System.out.println(countries.get(i));
}

Lors de l'initialisation, nous devons déclarer une variable entière pour spécifier le point de départ. Cette variable sert généralement d'index de liste.

La condition de fin est une expression qui, après l'évaluation, renvoie un booléen, une fois que cette expression est évaluée àfalse , la boucle se termine.

La clause update est utilisée pour modifier l'état actuel de la variable d'index, en l'augmentant ou en la diminuant jusqu'au moment de la terminaison.

2.2. Bouclefor améliorée

La bouclefor améliorée est une structure simple qui nous permet de visiter chaque élément d'une liste. Il est similaire à la base pour la boucle mais plus lisible et compact. Par conséquent, l’un des formulaires les plus couramment utilisés pour parcourir une liste.

Notez que la bouclefor améliorée est plus simple que la boucle de basefor:

for (String country : countries) {
    System.out.println(country);
}

3. Itérateurs

UnIterator est un design pattern qui nous offre une interface standard pour parcourir une structure de données sans avoir à se soucier de la représentation interne.

Cette façon de parcourir les structures de données offre de nombreux avantages, parmi lesquels nous pouvons souligner que notre code ne dépend pas de la mise en oeuvre.

Par conséquent, la structure peut être un arbre binaire ou une liste doublement chaînée puisque leIterator nous fait abstraction de la manière d'effectuer le parcours. De cette manière, nous pouvons facilement remplacer les structures de données dans notre code sans problèmes désagréables.

3.1. Iterator

En Java, le modèleIterator est reflété dans la classejava.util.Iterator. Il est largement utilisé dans JavaCollections. Il existe deux méthodes clés dans unIterator, les méthodeshasNext() etnext().

Ici, nous démontrons l'utilisation des deux:

Iterator countriesIterator = countries.iterator();

while(countriesIterator.hasNext()) {
    System.out.println(countriesIterator.next());
}

La méthodehasNext()checks if there are any elements remaining in the list.

La méthodenext()returns the next element in the iteration.

3.2. ListIterator

UnListIterator nous permet de parcourir une liste d'éléments dans l'ordre avant ou arrière.

Faire défiler une liste avecListIterator vers l'avant suit un mécanisme similaire à celui utilisé par lesIterator. De cette façon, nous pouvons faire avancer l'itérateur avec la méthodenext(), et nous pouvons trouver la fin de la liste en utilisant la méthodehasNext().

Comme nous pouvons le voir, leListIterator ressemble beaucoup auIterator que nous avons utilisé précédemment:

ListIterator listIterator = countries.listIterator();

while(listIterator.hasNext()) {
    System.out.println(listIterator.next());
}

4. forEach()

4.1. Iterable.forEach()

Since Java 8, we can use the forEach() method to iterate over the elements of a list. Cette méthode est définie dans l'interfaceIterable et peut accepter des expressions Lambda comme paramètre.

La syntaxe est assez simple:

countries.forEach(System.out::println);

Avant la fonctionforEach, tous les itérateurs en Java étaient actifs, c'est-à-dire qu'ils impliquaient une boucle for ou while qui traversait la collection de données jusqu'à ce qu'une certaine condition soit remplie.

Avec l'introduction deforEach en tant que fonction dans l'interfaceIterable, toutes les classes qui implémententIterable ont la fonctionforEach ajoutée.

4.2. Stream.forEach()

Nous pouvons également convertir une collection de valeurs en Stream et nous pouvons avoir accès à des opérations telles queforEach(),map(), oufilter().

Ici, nous démontrons une utilisation typique des flux:

countries.stream().forEach((c) -> System.out.println(c));

5. Conclusion

Dans cet article, nous avons montré les différentes manières de parcourir les éléments d'une liste à l'aide de l'API Java. Parmi ceux-ci, nous avons mentionné la bouclefor, le sloopfor amélioré, lesIterator, lesListIterator et la méthodeforEach() (incluse dans Java 8).

De plus, nous avons également montré comment utiliser la méthodeforEach() avecStreams.

Enfin, tout le code utilisé dans cet article est disponible dans nosGithub repo.

TOC