Java - Comment utiliser l'Iterator ?

Bienvenue, jeunes programmeurs ! Aujourd'hui, nous plongeons dans le monde fascinant des Iterators en Java. Ne vous inquiétez pas si vous êtes nouveau dans le monde de la programmation ; je vais vous guider pas à pas à travers ce concept, tout comme j'ai fait pour des centaines d'étudiants au fil des ans. Commençons cette aventure passionnante ensemble !

Qu'est-ce qu'un Iterator ?

Imaginez que vous avez une grande boîte pleine de briques de Lego colorées. Un Iterator est comme un assistant magique qui vous permet de passer chaque brique une par une, sans avoir à videz toute la boîte. C'est un moyen d'accéder aux éléments dans une collection séquentiellement, sans avoir besoin de connaître la structure sous-jacente de cette collection.

Pourquoi utiliser les Iterators ?

Les Iterators sont extrêmement utiles car ils fournissent une manière standard de parcourir différents types de collections (comme les listes, les ensembles ou les maps) en utilisant le même interface. Cela signifie que vous pouvez écrire du code qui fonctionne avec de nombreux types de collections différents sans changer votre logique de parcours.

L'interface Iterator

En Java, l'interface Iterator fait partie du Framework Collections de Java. Elle déclare les méthodes suivantes :

Méthode	Description
hasNext()	Retourne true si il y a plus d'éléments dans la collection
next()	Retourne l'élément suivant dans la collection
remove()	Supprime le dernier élément retourné par next() (opération optionnelle)

Utilisation de base de l'Iterator

Commençons avec un exemple simple pour voir comment fonctionne un Iterator :

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorExample {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");

Iterator<String> iterator = fruits.iterator();

while (iterator.hasNext()) {
String fruit = iterator.next();
System.out.println(fruit);
}
}
}

Dans cet exemple, nous créons une liste de fruits puis utilisons un Iterator pour parcourir chaque fruit et l'imprimer. Voici comment cela fonctionne :

1. Nous créons une ArrayList de chaînes et ajoutons quelques fruits.
2. Nous obtenons un Iterator à partir de la liste en utilisant la méthode iterator().
3. Nous utilisons une boucle while pour vérifier si il y a plus d'éléments (hasNext()).
4. À l'intérieur de la boucle, nous utilisons next() pour obtenir le fruit suivant et l'imprimer.

Lorsque vous exécutez ce code, vous verrez chaque fruit imprimé sur une ligne séparée. C'est comme si notre Iterator picking picking chaque fruit de la boîte et le nous montrait un par un !

L'interface ListIterator

Pour les listes, Java fournit un iterator amélioré appelé ListIterator. Il étend l'interface Iterator et ajoute plus de fonctionnalités :

Méthode	Description
add(E e)	Insère l'élément spécifié dans la liste
hasPrevious()	Retourne true si il y a des éléments précédents
previous()	Retourne l'élément précédent dans la liste
nextIndex()	Retourne l'index de l'élément qui serait retourné par next()
previousIndex()	Retourne l'index de l'élément qui serait retourné par previous()
set(E e)	Remplace le dernier élément retourné par next() ou previous()

Utilisation de ListIterator

Voyons comment nous pouvons utiliser un ListIterator pour parcourir une liste dans les deux sens :

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorExample {
public static void main(String[] args) {
List<String> colors = new ArrayList<>();
colors.add("Red");
colors.add("Green");
colors.add("Blue");

ListIterator<String> listIterator = colors.listIterator();

System.out.println("Direction forward:");
while (listIterator.hasNext()) {
System.out.println(listIterator.next());
}

System.out.println("\nDirection backward:");
while (listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
}
}
}

Dans cet exemple, nous utilisons un ListIterator pour parcourir notre liste de couleurs vers l'avant et puis vers l'arrière. C'est comme pouvoir marcher à travers nos briques de Lego du début à la fin, puis en sens inverse !

Modification des Collections pendant l'itération

Une des grandes choses à propos des Iterators est qu'ils vous permettent de modifier la collection pendant que vous l'itérez. regardons un exemple où nous supprimons des éléments qui remplissent certains critères :

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorRemoveExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
numbers.add(i);
}

Iterator<Integer> iterator = numbers.iterator();
while (iterator.hasNext()) {
Integer number = iterator.next();
if (number % 2 == 0) {
iterator.remove();
}
}

System.out.println("Numbers odd: " + numbers);
}
}

Dans cet exemple, nous supprimons tous les nombres pairs de notre liste. Nous utilisons la méthode remove() de l'Iterator pour supprimer des éléments en toute sécurité pendant l'itération. Si nous essayions de supprimer des éléments directement de la liste pendant l'itération, nous obtiendrions une ConcurrentModificationException. C'est comme être capable de supprimer certaines briques de Lego de notre boîte pendant que nous les passons en revue, sans perturber notre processus de tri !

Conclusion

Les Iterators sont un outil puissant en Java qui nous permettent de parcourir les collections efficacement et en toute sécurité. Ils fournissent une manière uniforme d'accéder aux éléments dans différents types de collections, rendant notre code plus flexible et réutilisable.

Souvenez-vous, la programmation est comme construire avec des briques de Lego. Les Iterators ne sont qu'un des nombreux outils cool que vous avez à votre disposition. Continuez à pratiquez, continuez à explorer, et bientôt vous construirez des choses incroyables avec Java !

Bonne programmation, futurs programmeurs ! ??‍??‍?

Credits: Image by storyset