Menu

Java Iterator: Apprenez à utiliser les itérateurs en Java avec des exemples

  • Principal
  • Autre
  • Java Iterator: Apprenez à utiliser les itérateurs en Java avec des exemples

java iterator learn use iterators java with examples

Essayez Notre Instrument Pour Éliminer Les Problèmes

Dans ce didacticiel, nous allons en apprendre davantage sur les itérateurs en Java. Nous aurons une discussion détaillée sur les interfaces Iterator et ListIterator en Java:

Nous avons exploré tout sur le Java Collection Framework et ses différentes interfaces et classes de support dans l'un de nos tutoriels précédents.

Lorsque vous avez une collection, vous souhaitez accéder à ses éléments, ajouter / supprimer ou traiter les éléments. Pour effectuer tout ce traitement via un programme Java, vous devriez pouvoir parcourir la collection que vous utilisez. C'est là que l'itérateur entre en scène.

Itérateur Java

Ce que vous apprendrez:

Qu'est-ce qu'un itérateur Java?

En Java, un itérateur est une construction utilisée pour parcourir ou parcourir la collection.

Pour utiliser un itérateur, vous devez obtenir l'objet itérateur en utilisant le ' itérateur () ' méthode de l'interface de collecte. Java Iterator est une interface de structure de collecte et fait partie du package «java.util». À l'aide de Java Iterator, vous pouvez parcourir la collection d'objets.

L'interface Java Iterator remplace l'énumérateur qui était utilisé précédemment pour parcourir certaines collections simples telles que les vecteurs.

Les principales différences entre Java Iterator et Enumerator sont:

  • Amélioration considérable des noms de méthodes.
  • Vous pouvez supprimer des éléments de méthode de la collection qui est parcourue à l'aide d'un itérateur.

Dans ce didacticiel, nous discuterons des détails de l'interface Iterator et de l'interface ListIterator qui est une interface bidirectionnelle.

Types d'itérateurs

  • Recenseur
  • Itérateur
  • ListIterator

Un Enumérateur est rarement utilisé maintenant. Par conséquent, dans notre série de didacticiels, nous nous concentrerons sur les interfaces Iterator et ListIterator.

Interface Iterator en Java

L’interface Iterator en Java fait partie du framework Collections du package ‘java.util’ et est un curseur qui peut être utilisé pour parcourir la collection d’objets.

L'interface Iterator présente les principales caractéristiques suivantes:

  • L'interface Iterator est disponible à partir du framework de collecte Java 1.2.
  • Il parcourt la collection d'objets un par un.
  • Populairement connu sous le nom de «Universal Java Cursor» car il fonctionne avec toutes les collections.
  • Cette interface prend en charge les opérations de lecture et de suppression, c'est-à-dire que vous pouvez supprimer un élément pendant une itération à l'aide de l'itérateur.

La représentation générale de l'interface d'itérateur est donnée ci-dessous:

Représentation de l

Ensuite, examinons les méthodes Iterator répertoriées ci-dessus.

Méthodes d'itérateur

L'interface Iterator prend en charge les méthodes suivantes:

# 1) Suivant ()

Prototype: E suivant ()
Paramètres: pas de paramètres
Type de retour: E -> élément
Description: Renvoie l'élément suivant de la collection.

Si l'itération (collection) n'a plus d'éléments, alors elle lance NoSuchElementException .

# 2) hasNext ()

Prototype: booléen hasNext ()
Paramètres: NÉANT
Type de retour: true => il y a des éléments dans la collection.

Faux => plus d'éléments

Description: La fonction hasNext () vérifie s'il y a plus d'éléments dans la collection auxquels on accède à l'aide d'un itérateur. S'il n'y a plus d'éléments, vous n'appelez pas la méthode next (). En d'autres termes, cette fonction peut être utilisée pour décider si la méthode next () doit être appelée.

# 3) supprimer ()

Prototype: void remove ()
Paramètres: NÉANT
Type de retour: NÉANT

Description: Supprime le dernier élément renvoyé par l'itérateur effectuant une itération sur la collection sous-jacente. La méthode remove () ne peut être appelée qu'une seule fois par appel next ().

Si l'itérateur ne prend pas en charge l'opération de suppression, il lance UnSupportedOperationException . Il jette IllegalStateException si la méthode suivante n'est pas encore appelée.

# 4) pourEachRemaining ()

Prototype: void forEachRemaining (consommateurEST > action)
Paramètres: action => action à effectuer
Type de retour: annuler

Description: Exécute l'action spécifiée sur chacun des éléments restants de la collection jusqu'à ce que tous les éléments soient épuisés ou que l'action lève une exception. Les exceptions levées par l'action sont propagées à l'appelant.

Si l'action est nulle, alors elle déclenche nullPointerException . Cette fonction est un nouvel ajout à l'interface Iterator de Java 8.

Exemple d'itérateur Java

Implémentons un programme Java pour démontrer l'utilisation de l'interface Iterator. Le programme suivant crée une ArrayList de fleurs. Ensuite, il obtient un itérateur en utilisant la méthode iterator () de ArrayList. Après cela, la liste est parcourue pour afficher chaque élément.

import java.util.*; public class Main { public static void main(String() args) { List flowers = new ArrayList(); flowers.add('Rose'); flowers.add('Jasmine'); flowers.add('sunflower'); // Get Iterator IteratorflowersIterator = flowers.iterator(); System.out.println('Contents of ArrayList:'); // Traverse elements using iterator while(flowersIterator.hasNext()){ System.out.print(flowersIterator.next() + ' '); } } }

Production:

Exemple d

Limitations de l'interface d'itérateur

  • L'opération de remplacement d'un élément ou d'ajout d'un nouvel élément ne peut pas être effectuée avec cet itérateur.
  • L'itération se déroule uniquement dans une direction, c'est-à-dire la direction avant.
  • Prend en charge uniquement l'itération séquentielle.
  • Lorsque de gros volumes de données doivent être itérés, les performances de l'itérateur sont affectées.

Itérateur VsItérable

Bien que les interfaces Iterable et Iterator semblent similaires, elles sont complètement différentes. Une classe qui implémente l'interface Iterable acquiert la capacité d'itérer sur les objets de classe qui utilisent l'interface d'itérateur.

Vous trouverez ci-dessous quelques-unes des principales différences entre ces deux interfaces dont vous devez être conscient:

Interface itérable Interface d'itérateur
Représente une collection qui peut être parcourue à l'aide de la boucle foreach.Permet d'itérer sur une autre collection.
La classe qui implémente l'interface itérable doit remplacer la méthode iterator ().Les méthodes hasNext () et next () de l'interface Iterator doivent être remplacées par la classe qui l'implémente.
Ne stocke pas l'état actuel.Stocke l'état actuel de l'itération.
Une instance de l'interface de l'itérateur doit être produite chaque fois que la méthode iterator () est appelée.Aucun contrat de ce type pour l'interface de l'itérateur.
Se déplace uniquement vers l'avant.Se déplace vers l'avant et les sous-interfaces telles que listIterator prennent en charge la traversée bidirectionnelle.
Ne fournit aucune méthode pour modifier les éléments pendant l'itération.Fournit la méthode remove qui peut supprimer l'élément lorsque l'itération est en cours.

Interface ListIterator en Java

L'interface ListIterator est une sous-interface de l'interface de l'itérateur. Il fonctionne sur des collections de type liste comme les Linkedlists, les listes de tableaux, etc. Ainsi, cette interface surmonte les lacunes de l'interface Iterator.

Les principales caractéristiques de l'interface ListIterator incluent:

  • L'interface ListIterator étend l'interface Iterator.
  • L'interface ListIterator prend en charge les opérations CRUD, c'est-à-dire créer, lire, mettre à jour et supprimer.
  • Prend en charge l'itération dans le sens avant et arrière.
  • Comme cette interface est bidirectionnelle, le curseur est toujours positionné entre les éléments précédent et suivant.
  • Cette interface fonctionne principalement pour les implémentations de liste telles que ArrayList, LinkedList, etc.
  • Disponible depuis Java 1.2

L'interface ListIterator est représentée comme indiqué ci-dessous:

Représentation de l

Comme déjà mentionné, l'interface ListIterator étend l'interface Iterator. Ainsi, en plus de prendre en charge toutes les méthodes de l'interface d'itérateur, comme décrit ci-dessus, l'interface ListIterator a également ses propres méthodes qui l'aident à effectuer des opérations CRUD ainsi qu'une itération bidirectionnelle.

Laissez-nous discuter des méthodes ListIterator en détail.

Méthodes ListIterator

Notez que les méthodes d'interface Iterator, next (), hasNext () et remove () fonctionnent exactement, de la même manière, que l'interface ListIterator. Par conséquent, nous ignorerons ces méthodes dans cette section. En plus des méthodes mentionnées ci-dessus, ListIterator a les méthodes suivantes:

Précédent()

Prototype: E précédent ()
Paramètres: NÉANT
Type de retour:
E- élément précédent dans la liste.
- 1 - si l'itérateur est au début de la liste.

Description: Cette fonction renvoie l'élément précédent de la liste. Une fois l'élément précédent renvoyé, le curseur est déplacé vers l'arrière vers l'élément suivant.

hasPrevious ()

Prototype: booléen hasPrevious ()
Paramètres: NÉANT
Type de retour: true => l'itérateur a plus d'éléments lorsque la liste est parcourue en arrière.

Description: Cette fonction vérifie si ListIterator a plus d'éléments dans le sens inverse.

previousIndex

Prototype: int previousIndex ()
Paramètres: NÉANT
Type de retour:
int - index de l'élément précédent
- 1 - si le pointeur est au début de la liste.

Description: Renvoie l'index de l'élément précédent renvoyé par l'appel précédent ().

nextIndex

Prototype: int nextIndex()
Paramètres: NÉANT
Type de retour:
int - index suivant
- 1 - si l'itérateur est à la fin de la liste.

Description: Renvoie l'index suivant de l'élément dans la liste. Cet élément est retourné par un appel à la méthode next ().

ensemble()

Prototype: ensemble vide (E et)
Paramètres: e - élément à remplacer
Type de retour: NÉANT

Description: Utilisé pour remplacer le dernier élément par l'élément donné e.

ajouter()

Prototype: void add (E e)
Paramètres: e - élément à ajouter
Type de retour: NÉANT

Description: Ajoute de nouveaux éléments à la liste à une position avant celle de l'élément suivant ().

Exemple d'itérateur de liste

Maintenant, nous savons ce qu'est un ListIterator et quelles sont les différentes méthodes prises en charge par celui-ci. Allons-y et implémentons un programme Java pour démontrer ListIterator.

Dans ce programme, nous avons utilisé ArrayList. Ensuite, nous utilisons les méthodes ListIterator pour parcourir la liste dans le sens avant et arrière et afficher la sortie.

import java.util.*; class Main { public static void main(String args()) { Listnum_list = new ArrayList(); // Add Elements to ArrayList num_list.add(1); num_list.add(3); num_list.add(5); num_list.add(7); num_list.add(9); // Creatinge a ListIterator ListIteratorlist_it = num_list.listIterator(); System.out.println('Output using forward iteration:'); while (list_it.hasNext()) System.out.print(list_it.next()+' ') ; System.out.print(' Output using backward iteration: ') ; while (list_it.hasPrevious()) System.out.print(list_it.previous()+' '); } }

Production:

ListIterator - Sortie

Jusqu'à présent, nous avons discuté des interfaces, de l'itérateur et du Listiterator, nous verrons ensuite les différents exemples d'utilisation de ces interfaces pour traverser différentes collections. Mais d'abord, examinons la traversée de tableaux simples, puis passons à d'autres collections.

Itérateur de tableau

En Java, il existe deux façons d'itérer sur des éléments de tableau. Décrivons les façons d'utiliser des exemples de code.

# 1) pour la boucle

C'est la manière la plus simple d'itérer sur un tableau. Nous utilisons une simple boucle for qui incrémentera l'index à chaque itération et affichera son contenu.

import java.util.*; public class Main { public static void main(String() args) { int myArray() = {2,4,6,8,10,12,14}; int num; System.out.println('Array contents using for loop:'); for (int i = 0; i

Production:

Array Iterator pour boucle

Le programme ci-dessus affiche le contenu du tableau en utilisant la boucle for.

# 2) forEach boucle

C'est la deuxième manière d'itérer sur des tableaux. Ici, nous utilisons une boucle for spécialisée ou une boucle «forEach». Ici, nous parcourons le tableau pour chaque élément, puis nous affichons le contenu.

import java.util.*; public class Main { public static void main(String() args) { int myArray() = {2,4,6,8,10,12,14}; int num; System.out.println('Array contents using for each loop:'); for (int i :myArray) { // accessing each element of array num = i; System.out.print(num + ' '); } } }

Production:

Itérateur de tableau - sortie

Le forEach est plus optimisé que la boucle for. Il est plus court à taper et plus rapide aussi.

Itérateur ArrayList

Si vous souhaitez parcourir une collection ArrayList, vous pouvez le faire à l'aide de l'interface Iterator. Comme l'itérateur est une interface, vous ne pouvez pas l'instancier directement. À la place, vous pouvez utiliser la méthode iterator () de la collection ArrayList pour obtenir l’itérateur, puis parcourir la liste.

Itérateur itérateur ();

Exemple pour illustrer l'itérateur ArrayList.

import java.util.*; public class Main { public static void main(String() args) { ArrayListmyList = new ArrayList(); myList.add('Red'); myList.add('Green'); myList.add('Blue'); myList.add('Brown'); myList.add('Pink'); myList.add('Purple'); Iteratorlist_it = myList.iterator(); System.out.println('Elements in the arrayList:'); while(list_it.hasNext()) System.out.print(list_it.next() + ' '); } }

Production:

Itérateur ArrayList

Itérateur LinkedList

Voyons maintenant la fonctionnalité d'un itérateur en cas de collection LinkedList.

La collection LinkedList prend en charge la méthode listIterator () qui renvoie le listIterator pour parcourir la liste liée.

Le format général de cette fonction est

ListIterator list_iter = LinkedList.listIterator (index int);

Ici, l'index est une valeur entière qui spécifie la position dans la collection de listes liées à partir de laquelle le parcours doit commencer.

Comprenons l'itérateur de liste dans la liste chaînée avec un exemple de programme. Nous avons modifié le même programme itérateur de tableau et l'avons changé pour qu'il contienne un listiterator avec LinkedList.

import java.util.*; public class Main { public static void main(String() args) { LinkedListmyList = new LinkedList(); myList.add('Red'); myList.add('Green'); myList.add('Blue'); myList.add('Brown'); myList.add('Pink'); myList.add('Purple'); ListIteratorlist_it = myList.listIterator(0); System.out.println('Elements in the LinkedList:'); while(list_it.hasNext()) System.out.print(list_it.next() + ' '); } }

Production:

casque vr pour xbox one x

Itérateur LinkedList - sortie

Java Map / Hashmap Iterator

La carte ou ses variations comme hashmap, treemap, etc. ne sont pas des collections. Par conséquent, vous ne pouvez pas utiliser directement la méthode iterator dessus. Au lieu de cela, vous devez parcourir les valeurs d'entrée de clé pour lire les paires clé / valeur.

Bien que vous puissiez utiliser diverses méthodes comme forEach, for loop, etc. pour itérer sur les valeurs de la carte, l'utilisation d'un itérateur pour parcourir les valeurs de clé est la meilleure et la plus efficace. En outre, vous pouvez également supprimer des entrées de la carte pendant l'itération à l'aide de la méthode remove.

Exemple d'utilisation de l'itérateur avec HashMap.

import java.util.*; class Main { public static void main(String() arg) { MapmyMap = new HashMap(); // enter name/url pair myMap.put(1, 'India'); myMap.put(2, 'Nepal'); myMap.put(3, 'Maldives'); myMap.put(4, 'SriLanka'); System.out.println(' SAARC Member Countries '); System.out.println(' KEY' + ' ' + ' COUNTRY' ); // using iterators Iteratormap_itr = myMap.entrySet().iterator(); while(map_itr.hasNext()) { Map.Entrymap_entry = map_itr.next(); System.out.println(' ' + map_entry.getKey() + ' ' + map_entry.getValue()); } } }

Production:

Itérateur de hashmap Javamap

Dans le programme ci-dessus, nous avons défini une carte avec des clés entières et des valeurs de type chaîne. Ensuite, nous définissons un itérateur sur la carte. Saisissez et affichez les paires clé / valeur.

Itérateur d'ensemble Java

La méthode iterator () de Java.util.set est utilisée pour obtenir l'itérateur qui renvoie les éléments de l'ensemble dans un ordre aléatoire.

Iterator set_iterator = Set.iterator();

Le «set_iterator» itère sur les différents éléments de l'ensemble et renvoie leurs valeurs.

De la même manière, l'ensemble de hachage contient également une fonction d'itérateur qui renvoie un itérateur comme un itérateur d'ensemble.

Iterator hashset_iterator = Hash_Set.iterator();

Vous trouverez ci-dessous l'exemple de programmation pour illustrer l'itérateur défini.

import java.util.*; public class Main { public static void main(String args()) { HashSetsports_set = new HashSet(); sports_set.add('Hocky'); sports_set.add('Kabaddi'); sports_set.add('Football'); sports_set.add('Badminton'); sports_set.add('Cricket'); System.out.println('Sports HashSet: ' + sports_set); // Creating an iterator Iterator hashset_iter = sports_set.iterator(); // Displaying the values after iterating through the set System.out.println(' SportsSet iterator values:'); while (hashset_iter.hasNext()) { System.out.println(hashset_iter.next()); } } }

Production:

Itérateur d

Cette implémentation utilise le Itérateur HashSet et affiche des valeurs individuelles en itérant sur les éléments HashSet.

Iterator vs ListIterator

Passons en tableau les principales différences entre les interfaces Iterator et ListIterator.

Itérateur ListIterator
Peut parcourir toutes les collections, y compris l'ensemble, la carte, etc.Il peut être utilisé pour parcourir uniquement une collection de type liste comme ArrayList, LinkedList.
Itère la collection uniquement dans le sens avant.Peut parcourir la collection aussi bien vers l'avant que vers l'arrière.
Impossible d'obtenir les index.Peut obtenir des index.
Aucun moyen d'ajouter de nouveaux éléments à la collection.Vous pouvez ajouter de nouveaux éléments à la collection.
Iterator ne peut pas modifier les éléments pendant l'itération.ListIterator peut modifier les éléments de la collection à l'aide de la méthode set ().

Questions fréquemment posées

Q # 1) Quelle est l'itération en Java?

Répondre: Une itération est un processus par lequel un bloc de code est exécuté de manière répétée jusqu'à ce qu'une condition donnée soit maintenue ou n'existe pas. En utilisant l'itération, vous pouvez parcourir une séquence d'éléments ou traiter les données.

Q # 2) Combien de types d'itérateurs existe-t-il en Java?

Répondre: Les itérateurs sont utilisés pour parcourir les collections en Java.

Il existe trois types d'itérateurs en Java:

  • Les recenseurs
  • Itérateurs
  • ListeIterators

Q # 3) Comment utiliser un itérateur en Java?

Répondre: Afin d'utiliser l'itérateur pour parcourir la collection, vous devez d'abord obtenir l'itérateur en utilisant la méthode iterator () de la collection spécifiée.

Ensuite, vous pouvez utiliser les méthodes hasNext () et next () de l'itérateur pour obtenir l'élément.

Q # 4) Pourquoi Iterator est-il utilisé à la place de la boucle for?

Répondre: L'itérateur et la boucle for sont utilisés pour exécuter à plusieurs reprises un bloc de code spécifique. Mais la principale différence est que dans la boucle for, vous ne pouvez pas altérer ou modifier le contenu de la collection. Même si vous essayez de le modifier, cela lèvera une exception concurrentModificationException. En utilisant iterator, vous pouvez supprimer un élément de la collection.

Q # 5) Pourquoi avons-nous besoin d'itérateur en Java?

Répondre: Iterator vous aide à récupérer les éléments de la collection ou d'un conteneur sans que le programmeur ait à connaître la structure interne ou le fonctionnement de la collection. Ils sont plus élégants, consomment moins de mémoire et le programmeur est également épargné par l'écriture de code long.

Deuxièmement, les éléments peuvent être stockés dans la collection de n'importe quelle manière mais en utilisant un itérateur, le programmeur peut les récupérer comme une liste ou toute autre séquence.

Conclusion

Nous avons discuté des itérateurs en Java qui sont utilisés avec les collections dans ce didacticiel. Cette connaissance des itérateurs aidera les lecteurs à saisir les collections que nous allons apprendre dans nos tutoriels ultérieurs.

lecture recommandée