Un itérateur en Java est l'un des plus couramment utilisés curseurs dans Java Collections Framework . Il est utilisé pour parcourir ou parcourir les éléments d’une collection un par un.

• Il est utilisé pour parcourir les éléments dans le sens avant uniquement.
• Supprime les éléments en toute sécurité pendant le parcours à l'aide de remove().
• Iterator est un curseur universel qui s'applique à tous les types de collections : ensemble de listes et file d'attente.

Déclaration de l'itérateur

Itérateur d'interface publique

Ici, E représente le type d’éléments sur lesquels effectuer une itération.

Création d'objet d'itérateur

Un objet Iterator est créé en appelant la méthode iterator() sur un objet de collection. Ici, nous utiliserons un itérateur pour parcourir et imprimer chaque élément dans un Liste de tableaux .

Collection noms = nouvelle ArrayList <>();
Itérateur itr = noms.iterator();

   import     java.util.ArrayList  ;   import     java.util.Iterator  ;   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     {          // Create an ArrayList and add some elements      ArrayList   <  String  >     al     =     new     ArrayList   <>  ();      al  .  add  (  'A'  );      al  .  add  (  'B'  );      al  .  add  (  'C'  );      // Obtain an iterator for the ArrayList      Iterator   <  String  >     it     =     al  .  iterator  ();      // Iterate through the elements and print each one      while     (  it  .  hasNext  ())     {          // Get the next element      String     n     =     it  .  next  ();         System  .  out  .  println  (  n  );         }      }   }   

A B C  

Hiérarchie des itérateurs

L'itérateur fait partie du paquet java.util et est implémenté par toutes les classes de collection via leurs sous-interfaces.

Méthodes d'interface d'itérateur

L'interface de l'itérateur définit trois méthodes répertoriées ci-dessous :

• hasNext() : Renvoie vrai si l'itération comporte plus d'éléments.
• suivant(): Renvoie l'élément suivant dans l'itération. Ça jette NoSuchElementException si aucun autre élément n'est présent.
• retirer(): Supprime le dernier élément renvoyé par next(). Cette méthode ne peut être appelée qu'une seule fois par appel à next().

Note : La méthode Remove() peut générer deux exceptions, à savoir les suivantes :

Travail interne

Dans cette section, nous allons essayer de comprendre comment Java Iterator et ses méthodes fonctionnent en interne. Prenons l'objet LinkedList suivant pour comprendre cette fonctionnalité.

Étape 1 : Créons maintenant un objet Iterator sur l'objet List comme indiqué ci-dessous :

Itérateur villesIterator = villes.iterator();

L'itérateur 'citiesIteartor' ressemblera à ci-dessous :

Ici, le curseur de l'itérateur pointe avant le premier élément de la liste.

Étape 2 : Nous allons maintenant exécuter l'extrait de code suivant.

villesIterator.hasNext();
villesIterator.next();

Lorsque nous exécutons l'extrait de code ci-dessus, le curseur de l'itérateur pointe vers le premier élément de la liste, comme indiqué dans le diagramme ci-dessus.

Étape 3 : Nous allons maintenant exécuter l'extrait de code suivant.

villesIterator.hasNext();
villesIterator.next();

Lorsque nous exécutons l'extrait de code ci-dessus, le curseur de l'itérateur pointe vers le deuxième élément de la liste, comme indiqué dans le diagramme ci-dessus.

Étape 4 : Effectuez ce processus pour atteindre le curseur de l'itérateur jusqu'à l'élément final de la liste.

Étape 5 : Après avoir lu le dernier élément, si nous exécutons l'extrait de code ci-dessous, il renvoie une fausse valeur.

villesIterator.hasNext();

Comme le curseur de l'itérateur pointe vers l'après le dernier élément de la liste aSuivant() La méthode renvoie une valeur fausse.

Note: Java Iterator ne prend en charge que l'itération dans le sens avant, il est donc connu sous le nom de curseur unidirectionnel. En revanche, ListIterator est bidirectionnel permettant un parcours dans les deux sens.

Exemple: Ici, nous utiliserons un Iterator pour parcourir et supprimer les éléments impairs d’une ArrayList.

   import     java.util.ArrayList  ;   import     java.util.Iterator  ;   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     {          // Creating an ArrayList of Integer type      ArrayList   <  Integer  >     al     =     new     ArrayList   <>  ();      // Adding elements to the ArrayList      for     (  int     i     =     0  ;     i      <     10  ;     i  ++  )     {      al  .  add  (  i  );      }      // Printing the original list      System  .  out  .  println  (  'Original List: '     +     al  );      // Creating an Iterator for the ArrayList      Iterator   <  Integer  >     itr     =     al  .  iterator  ();      // Iterating through the list and removing odd elements      while     (  itr  .  hasNext  ())     {          // Getting the next element      int     i     =     itr  .  next  ();             System  .  out  .  print  (  i     +     ' '  );         // Removing odd elements      if     (  i     %     2     !=     0  )     {      itr  .  remove  ();      }      }      System  .  out  .  println  ();      // Printing the modified list after removal of odd elements      System  .  out  .  println  (  'Modified List: '     +     al  );      }   }   

Original List: [0 1 2 3 4 5 6 7 8 9] 0 1 2 3 4 5 6 7 8 9 Modified List: [0 2 4 6 8]  

Explication: Dans l'exemple ci-dessus, nous créons une ArrayList d'entiers, puis la parcourons à l'aide d'un itérateur et supprimons tous les nombres impairs. Il imprime la liste avant et après la suppression des éléments impairs et imprime la liste modifiée avec uniquement des nombres pairs.