TOC

Guide d’Iterator en Java

Guide d'Iterator en Java

1. introduction

UnIterator est l'un des nombreux moyens de parcourir une collection et, comme chaque option, il a ses avantages et ses inconvénients.

Il a été introduit pour la première fois dans Java 1.2 en remplacement deEnumerations et:

Dans ce didacticiel, nous allons passer en revue l'interface simple deIterator pour savoir comment nous pouvons utiliser ses différentes méthodes.

Nous allons également vérifier l'extensionListIterator plus robuste qui ajoute des fonctionnalités intéressantes.

2. L'interfaceIterator

Pour commencer, nous devons obtenir unIterator à partir d'unCollection; cela se fait en appelant la méthodeiterator().

Pour plus de simplicité, nous obtiendrons l'instanceIterator à partir d'une liste: 

List items = ...
Iterator iter = items.iterator();

L'interfaceIterator a trois méthodes principales:

2.1. hasNext()

La méthodehasNext() peut être utilisée pour vérifier s'il reste au moins un élément à parcourir.

Il est conçu pour être utilisé comme condition dans les boucleswhile: 

while (iter.hasNext()) {
    // ...
}

2.2. next()

La méthodenext() peut être utilisée pour passer à l'élément suivant et l'obtenir: 

String next = iter.next();

Il est recommandé d’utiliserhasNext() avant de tenter d’appelernext().

Iterators pourCollections ne garantit pas l'itération dans un ordre particulierunless particular implementation provides it.

2.3. remove()

Enfin, si nous voulonsremove the current element from the collection,, nous pouvons utiliser lesremove: 

iter.remove();

C'est un moyen sûr de supprimer des éléments lors d'une itération sur une collection sans risque deConcurrentModificationException.

2.4. Exemple deIterator complet

Maintenant, nous pouvons tous les combiner et voir comment nous utilisons les trois méthodes ensemble pour filtrer les collections: 

while (iter.hasNext()) {
    String next = iter.next();
    System.out.println(next);

    if( "TWO".equals(next)) {
        iter.remove();
    }
}

C'est ainsi que nous utilisons couramment unIterator, que nous vérifions à l'avance s'il y a un autre élément, nous le récupérons puis nous effectuons une action dessus.

2.5. Itération avec des expressions Lambda

Comme nous l'avons vu dans les exemples précédents, il est très verbeux d'utiliser unIterator lorsque nous voulons simplement passer en revue tous les éléments et faire quelque chose avec eux.

Depuis Java 8, nous avons la méthodeforEachRemaining qui permet l'utilisation de lambdas pour traiter les éléments restants: 

iter.forEachRemaining(System.out::println);

3. L'interfaceListIterator

ListIterator est une extension qui ajoute de nouvelles fonctionnalités pour itérer sur des listes: 

ListIterator listIterator = items.listIterator(items.size());

Remarquez comment nous pouvons fournir une position de départ qui dans ce cas est la fin desList.

3.1. hasPrevious() etprevious()

ListIterator peut être utilisé pour la traversée vers l'arrière afin de fournir des équivalents dehasNext() etnext(): 

while(listIterator.hasPrevious()) {
    String previous = listIterator.previous();
}

3.2. nextIndex() etpreviousIndex()

De plus, nous pouvons parcourir des index et non des éléments réels: 

String nextWithIndex = items.get(listIterator.nextIndex());
String previousWithIndex = items.get(listIterator.previousIndex());

Cela peut s'avérer très utile au cas où nous aurions besoin de connaître les index des objets que nous modifions actuellement, ou si nous souhaitons conserver un enregistrement des éléments supprimés.

3.3. add()

La méthodeadd, qui, comme son nom l'indique, permet d'ajouter un élémentbefore the item that would be returned by next() and after the one returned by previous(): 

listIterator.add("FOUR");

3.4. set()

La dernière méthode à mentionner estset(), qui nous permet de remplacer l'élément qui a été renvoyé lors de l'appel ànext() ouprevious(): 

String next = listIterator.next();
if( "ONE".equals(next)) {
    listIterator.set("SWAPPED");
}

Il est important de noter quethis can only be executed if no prior calls to add() or remove() were made.

3.5. Exemple deListIterator complet

Nous pouvons maintenant les combiner tous pour en faire un exemple complet: 

ListIterator listIterator = items.listIterator();
while(listIterator.hasNext()) {
    String nextWithIndex = items.get(listIterator.nextIndex());
    String next = listIterator.next();
    if("REPLACE ME".equals(next)) {
        listIterator.set("REPLACED");
    }
}
listIterator.add("NEW");
while(listIterator.hasPrevious()) {
    String previousWithIndex
     = items.get(listIterator.previousIndex());
    String previous = listIterator.previous();
    System.out.println(previous);
}

Dans cet exemple, nous commençons par obtenir lesListIterator desList, puis nous pouvons obtenir l'élément suivant soit par index -which doesn’t increase the iterator’s internal current element - soit en appelantnext.

Ensuite, nous pouvons remplacer un élément spécifique parset et en insérer un nouveau paradd.

Après avoir atteint la fin de l'itération, nous pouvons revenir en arrière pour modifier d'autres éléments ou simplement les imprimer de bas en haut.

4. Conclusion

L'interfaceIterator permet de modifier une collection en la parcourant, ce qui est plus difficile avec une simple instruction for / while. Cela nous donne un bon modèle que nous pouvons utiliser dans de nombreuses méthodes qui ne nécessitent que le traitement des collectes tout en maintenant une bonne cohésion et un couplage faible.

Enfin, comme toujours, le code source complet est disponibleover at GitHub.

Related