Itérateur Java

Salut! Dans la leçon d'aujourd'hui, nous parlerons de Java Iterator. Imaginez que vous allez à la bibliothèque et que vous voulez trouver un livre en particulier. Comment faites-vous? Si ce n'est pas de la fiction, il y a le système décimal Dewey. S'il s'agit de fiction, ils sont triés par ordre alphabétique de leur nom de famille. Quoi que vous cherchiez, à un moment donné, vous devez parcourir les livres un par un jusqu'à ce que vous trouviez ce que vous cherchez. Chaque fois que vous avez une collection d'éléments en Java, qu'elle soit stockée dans un Array , un ArrayList , un Queue ou un List , comment trouvez-vous une valeur particulière ? À un moment donné, vous devez parcourir chaque élément un par un. C'est à cela que sert un itérateur Java.

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

Qu'est-ce qu'un itérateur en Java ? C'est une façon de regarder chaque élément d'une collection. Et par collection, nous entendons tout ce qui se trouve dans la classe Collection . Ceci comprend:

• Liste des tableaux
• HashSet
• LinkedHashSet
• Liste liée
• File d'attente de priorité
• Vecteur
• et plein d'autres…

Il inclut également les différentes interfaces de ces classes, telles que Set , List , Queue , Dequeue et Sorted Set , pour n'en nommer que quelques-unes. Iterator<E> est la méthode d'interface publique de la classe Interface Iterator<E> . Il a été introduit dans Java 1.2 et a remplacé Enumeration comme moyen d'examiner les éléments séquentiels d'une collection.

Pourquoi vous ne devriez pas utiliser les boucles For comme itérateur en Java

L'une des premières façons d'apprendre à tout le monde à parcourir une collection en Java est une boucle. Il ressemble à ceci :

class Main {
  public static void main(String[] args) {
    int exampleArray[] = new int[10];

    //fill array with data

    for(int x = 0; x < exampleArray.length; x++) {
      System.out.println("Content of element " + x + "is: " + exampleArray[x]);
    }
  }
}

La sortie serait une liste qui se lit comme suit :

Content of element 0 is: 0
Content of element 1 is: 1
Content of element 2 is: 2
etc.…

Cela a son utilité, mais que se passe-t-il si la collection ne stocke pas d'éléments dans un système basé sur un index ? Par exemple, Set s n'a pas d'ordre normalement. Il est donc conseillé de sortir de l'habitude d'utiliser une boucle for comme itérateur en Java et de s'entraîner à utiliser la classe Iterator<E> à la place. Voici quelques exemples d'itérateurs Java.

Comment utiliser Iterator en Java

Voici quelques exemples d'utilisation de l'itérateur en Java. Lors de l'utilisation de la classe iterator, il existe trois façons de parcourir une collection. Vous pouvez utiliser une boucle while() , une boucle for() et une boucle forEach() . Notez que cette boucle for est différente de celle dont nous avons parlé précédemment. Voici les trois exemples d'itérateurs Java différents. Tout d'abord, configurons la collection à parcourir.

import java.util.*; // imports ArrayList, Collection and Iterator

class Main {
  public static void main(String[] args) {
    Collection<String> example = new ArrayList<String>();

    example.add("Item 1");
    example.add("Item 2");
    example.add("Item 3");
    example.add("Item 4");
  }
}

Il s'agit d'une simple collection composée d'une ArrayList dans laquelle nous avons chargé quatre éléments. Examinons maintenant les trois méthodes d'utilisation de la classe Iterator pour parcourir ArrayList .

Boucle While()

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

while (iterator.hasNext()) {
   System.out.println("Element Value= " + iterator.next());
}

Cette boucle while() utilise la méthode booléenne .hasNext() de la classe Iterator pour vérifier s'il existe un élément futur. Si la condition préalable est vraie, alors elle se poursuit. S'il renvoie false, la boucle se termine. La partie clé ici est que les méthodes .hasNext () et .next () effectuent toutes deux une vérification initiale du premier élément. Si la collection est vide et qu'il n'y a pas de premier élément, la méthode renvoie false pour .hasNext() et lèvera une exception NoSuchElementException pour la méthode .next() .

Pour la boucle

for (Iterator<String> iterator = example.iterator(); iterator.hasNext();) {
  System.out.println("Element Value= " + iterator.next());
}

Cela ressemble à une boucle for plus traditionnelle. Il utilise la méthode .hasNext () comme vérification de condition et partie de modification. L'initialisation est l'appel à l'itérateur.

Pour : chaque boucle

for (String s : example) {
  System.out.println("Element Value= " + s);
}

La boucle For:Each est une boucle for, mais si vous ne savez pas comment la lire, cela peut être un peu déroutant. La syntaxe d'une boucle For:Each est for (data_type variableName : collectionName){ body} . Cette boucle for:each présente quelques inconvénients. Premièrement, il ne peut traverser la collection que dans une seule direction. Deuxièmement, vous devez parcourir chaque élément. Vous ne pouvez en ignorer aucun. Mais en tant qu'itérateur de liste pratique en Java, c'est la meilleure option. Du côté positif, la boucle for:each est très facile à lire et une fois que vous la connaissez, il est difficile de se tromper. Si vous vous demandez quelle est la sortie des trois boucles itératives, elles sont toutes identiques :

Element Value= Item 1
Element Value= Item 2
Element Value= Item 3
Element Value= Item 4 

Comment utiliser un itérateur en Java pour les cartes

Les cartes sont un moyen populaire de stocker des données, mais comme elles n'étendent pas Collection , vous ne pouvez pas utiliser les itérateurs précédents pour parcourir directement une carte. Alors, comment utiliser un itérateur en Java pour parcourir les Map s et HashMap s ? Il existe quatre bonnes méthodes d'itération de carte Java. Nous les couvrirons individuellement. Commençons par charger une carte avec une série de valeurs.

import java.util.*; //imports Map and HashMap

class Main {
  public static void main(String[] args) {
    Map<String, String> example = new HashMap<String, String>();

    example.put("alpha", "one");
    example.put("beta", "two");
    example.put("gamma", "three");

  }
}

Méthode Java Hashmap Iterator : forEach(action)

example.forEach((k,v) -> System.out.println("Key: "+ k + ", Value: " + v));

Cette méthode utilise une expression lambda pour itérer. L'opérateur lambda est la méthode forEach() et le corps imprime les valeurs. Cela utilise un opérateur à paramètres multiples. Il s'agit de la méthode la plus rapide et la plus propre pour l'itérateur de carte dans Java 8.

Méthode Java Hashmap Iterator : boucle For:Each()

for (Map.Entry<String, String> iterate : example.entrySet()) {
  System.out.println("Key: " + iterate.getKey() + ", Value: " + iterate.getValue());
}

Cela utilise la syntaxe For:Each pour appeler la méthode entrySet() afin de renvoyer un ensemble contenant la clé et la valeur comme éléments. De plus, lors de l'utilisation de la méthode .Entry() , les objets ne sont vrais que pendant cette itération.

Méthode Java Hashmap Iterator : Map.Entry<k, v>

Iterator<Map.Entry<String, String>> iterator = example.entrySet().iterator();

while(iterator.hasNext()){
  Map.Entry<String, String> element = iterator.next();
  System.out.println("Key: " + element.getKey() + ", Value: " + element.getValue());
)

Cette méthode convertit à nouveau la carte en un ensemble pour utiliser l'itérateur de collections et les méthodes. Pour ces trois méthodes d'itérateur, le retour ressemble à ceci :

Key: alpha, Value: one
Key: beta, Value: two
Key: gamma, Value: three
Java Hashmap Iterator Method: keySet() and values()
for (String key : example.keySet()) {
  System.out.println("Key: " + key);
}
for (String value : example.values()) {
  System.out.println("Value: " + value);
}

Celui-ci retourne les éléments d'une manière différente. Il renverra d'abord toutes les clés dans l'ordre, puis toutes les valeurs :

Key: alpha
Key: beta
Key: gamma
Value: one
Value: two
Value: three