Méthodes d'itération sur une liste en Java

1. Introduction

L'itération des é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, bien que l'inverse soit également simple.

2. pour la boucle

Tout d'abord, passons en revue certaines des options de boucle.

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

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

2.1. Boucle de base pour

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

La boucle for définit trois types d'instructions séparées par des points-virgules. La première instruction est l'instruction 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 agit généralement comme l'index de la liste.

La condition de terminaison 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 de mise à jour est utilisée pour modifier l'état actuel de la variable d'index, en l'augmentant ou en la diminuant jusqu'au point de terminaison.

2.2. Amélioré pour la boucle

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

Notez que la boucle for améliorée est plus simple que la boucle for de base :

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

3. Itérateurs

Un Iterator est un modèle de conception 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 l'implémentation.

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

3.1. Itérateur

En Java, le modèle Iterator est reflété dans la classe java.util.Iterator . Il est largement utilisé dans les collections Java . Il existe deux méthodes clés dans un Iterator , les méthodes hasNext () et next () .

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

Iterator countriesIterator = countries.iterator(); while(countriesIterator.hasNext()) { System.out.println(countriesIterator.next()); }

La méthode hasNext () vérifie s'il reste des éléments dans la liste .

La méthode next () retourne l'élément suivant de l'itération .

3.2. ListIterator

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

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

Comme nous pouvons le voir, le ListIterator ressemble beaucoup à l' Iterator 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 ()

Depuis Java 8, nous pouvons utiliser la méthode forEach () pour parcourir les éléments d'une liste . Cette méthode est définie dans l' interface Iterable et peut accepter des expressions Lambda en tant que paramètre.

La syntaxe est assez simple:

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

Avant la fonction forEach , tous les itérateurs de 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 de forEach en tant que fonction dans l' interface Iterable , toutes les classes qui implémentent Iterable ont la fonction forEach ajoutée.

4.2. Stream.forEach ()

Nous pouvons également convertir une collection de valeurs en un Stream et nous pouvons avoir accès à des opérations telles que forEach () , map () ou filter ().

Ici, nous 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 façons d'itérer les éléments d'une liste à l'aide de l'API Java. Parmi ceux-ci, nous avons mentionné la boucle for , la boucle for améliorée , l' Iterator , le ListIterator et la méthode forEach () (incluse dans Java 8).

De plus, nous avons également montré comment utiliser la méthode forEach () avec Streams .

Enfin, tout le code utilisé dans cet article est disponible dans notre référentiel Github.