Java >> Tutoriel Java >  >> Java

Itérateurs en Java

Java

Si vous êtes un débutant en Java ou même un programmeur expérimenté, vous pouvez être confronté à une situation où vous devez traverser tous les éléments d'une collection, afficher les éléments un par un, ou même récupérer chacun des éléments. C'est là que votre connaissance des itérateurs sera mise à l'épreuve.

Quelle est la différence entre l'utilisation d'itérateurs plutôt que l'utilisation de la boucle for et de la boucle while ? Ces deux éléments peuvent être utilisés pour parcourir une collection d'éléments, mais si vous devez supprimer certains éléments d'une collection lors de l'itération, les boucles ne peuvent pas être appliquées.

Par itération, nous entendons parcourir les éléments un par un. Cela implique des éléments d'une collection tels que LinkedList, ArrayList, HashMap e.t.c. Les itérateurs sont applicables lorsque l'on souhaite rechercher un élément particulier dans une collection, afficher les éléments un par un, accéder aux éléments de données d'une collection et supprimer des éléments de données spécifiques de la collection.

Il n'est pas possible d'inverser l'ordre d'itération. Les itérateurs parcourent une collection dans l'ordre de transfert et implémentent java. interface util.Iterator. Cela dit, nous pouvons conclure qu'un itérateur appartient au framework Java Collection.

Déclaration d'un itérateur

Iterator iterator_name = name_of_collection.iterator();
eg.
Iterator<Integer> numbers = values.iterator();

Méthodes utilisées par les itérateurs

  • Annuler la suppression () – =cette méthode est utilisée pour supprimer l'élément courant vers lequel pointe l'itérateur. Si vous appelez la méthode remove() sans appeler la méthode next(), une IllegalStateException est levée.
  • Objet suivant () =cette méthode renvoie l'élément suivant. S'il n'y a pas d'élément suivant, NoSuchElementException est levée.
  • Booléen hasNext() ==cette méthode renvoie true dans un scénario où nous avons l'élément suivant, sinon, renvoie false.

Exemple : 

package iterator;
import java.util.ArrayList;
import java.util.Iterator;
public class Iterator {
    public static void main(String[] args) {
          ArrayList<Integer> values = new ArrayList<Integer>();
        values.add(10);
        values.add(20);
        values.add(30);
        values.add(40);
        values.add(50);
        values.add(60);
        values.add(70);
        values.add(80);
        values.add(90);
       Iterator<Integer> numbers = values.iterator();
        while (numbers.hasNext()) 
        {
            int number = numbers.next();
            System.out.print(number + " ");
            if (number == 30)
                numbers.remove();
        }
        System.out.println("\n================");
        numbers = values.iterator();
        while (numbers.hasNext()) 
        {
            int number = numbers.next();
            System.out.print(number + " ");
        }        
    }
    
}

Sortie :

run:
10 20 30 40 50 60 70 80 90 
================
10 20 40 50 60 70 80 90 BUILD SUCCESSFUL (total time: 0 seconds)

À partir de l'exemple ci-dessus, nous avons appliqué les trois méthodes d'un Iterator :next( ), remove( ) et hasNext( ). Nous avons utilisé deux boucles while. La première boucle while imprime tous les éléments jusqu'à un point où l'itérateur n'a pas d'élément suivant. Il supprime également '30' de la ArrayList. La deuxième boucle while imprime les valeurs de la ArrayList après avoir supprimé l'élément 30.

Fonctionnalités importantes des itérateurs en Java

  • Permet de parcourir les éléments d'une collection
  • Autoriser l'accès aux éléments d'une collection
  • Permet l'affichage des éléments un par un dans une collection
  • Permet de supprimer un élément d'une collection tout en y accédant
  • Autorise l'accès direct aux éléments d'une collection

Exemples d'itérateurs en Java

Itérateur de liste

C'est un itérateur qui traverse une liste. Il ne s'applique qu'aux classes telles que Array List et LinkedList. Un itérateur de liste permet la traversée bidirectionnelle. Il utilise ses méthodes 'hasNext ( )' et 'next ( )' pour l'itération.

package iterator;
import java.util.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class Iterator {
    public static void main(String[] args) {
         // create a list
	List<String> cars = new ArrayList<String>();
	// add elements
	cars.add("Toyota");
	cars.add("Benz");
	cars.add("Mercidez");
        cars.add("Noah");
        cars.add("Corolla");
	// get iterator over the list
	java.util.Iterator<String> iterator = cars.iterator();
	// iterate over the list
	while (iterator.hasNext()) {
		// get current element
		String element = iterator.next();
		System.out.println(element);
	}        
    }    
}

Sortie :

run:
Toyota
Benz
Mercidez
Noah
Corolla
BUILD SUCCESSFUL (total time: 0 seconds)

À partir de l'exemple ci-dessus, nous avons commencé par créer une liste de voitures. Ajout d'éléments à la liste à l'aide de la méthode "add( )". Pour parcourir la liste, nous avons créé un itérateur. Utilisation des méthodes hasNext ( ) et next ( ) pour parcourir et afficher les éléments de la liste.

Définir l'itérateur

On peut aussi effectuer une itération sur un ensemble. En Java, nous nous référons à un ensemble comme une collection qui ne contient pas d'éléments en double. Java a trois implémentations d'ensemble à usage général, qui incluent ; HashSet, LinkedHashSet et TreeSet. Dans l'exemple ci-dessous, nous examinerons la traversée de HashSet, qui stocke ses éléments dans une table de hachage.

package iterator;
import java.util.HashSet;
//import java.util.Iterator;
import java.util.Set;
public class Iterator {
    public static void main(String[] args) {
         // create a set
	Set<String> cars = new HashSet<String>();
	// add elements to he set
	cars.add("Toyota");
	cars.add("Benz");
	cars.add("Mercidez");
        cars.add("Noah");
        cars.add("Corolla");
	// get iterator over the set
	Iterator<String> iterator = cars.iterator();
	// iterate over the set
	while (iterator.hasNext()) {
		// get current element
		String element = iterator.next();
		System.out.println(element);
	}        
    }   
}

Sortie :

run:
Toyota
Mercidez
Benz
Noah
Corolla
BUILD SUCCESSFUL (total time: 0 seconds)

Itérateur de carte

Une carte en Java est un objet qui mappe des clés à des valeurs. Pour une Map, nous ne pouvons pas itérer directement. Au lieu de cela, nous allons parcourir son ensemble de valeurs comme indiqué ci-dessous.

package iterator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class Iterator {
    public static void main(String[] args) {
         // create a hashmp
	Map<Integer, String> cars = new HashMap<Integer, String>();
	// add elements to the map
	cars.put(1, "Toyota");
	cars.put(2, "Benz");
	cars.put(3, "Mercidez");
    cars.put(4, "Noah");
    cars.put(5, "Corolla");
	// get iterator over map values
	Iterator<Integer> iterator = cars.keySet().iterator();
	// iterate over the set
	while (iterator.hasNext()) {
		// get current element
		Integer key = iterator.next();
		System.out.println("value:" + cars.get(key));
	}        
    }
}

Sortie :

run:
value:Toyota
value:Benz
value:Mercidez
value:Noah
value:Corolla
BUILD SUCCESSFUL (total time: 0 seconds)

À partir de l'exemple ci-dessus, nous parcourons la carte en utilisant son ensemble de clés. Chaque clé correspond à au plus une valeur.

Avantages de l'itérateur Java

  • Peut être utilisé dans n'importe quelle classe de collection
  • Il prend en charge les opérations READ et REMOVE
  • Ses noms de méthodes faciles à utiliser

Inconvénients de l'itérateur Java

  • Il ne prend pas en charge les opérations CREATE et Update
  • Ne prend pas en charge l'ordre inverse mais le sens avant uniquement

Types d'itérateurs

Nous pouvons également classer les itérateurs de deux manières :itérateur rapide et itérateur sécurisé.

  • Itérateur rapide :ce type d'itérateur échoue une fois que la structure d'une collection a changé depuis le début de la boucle. Par là, changer signifie; accéder, ajouter, mettre à jour ou supprimer des éléments d'une collection.
  • Itérateur à sécurité intégrée - ce type d'itérateur ne lève aucune exception en cas de modification au moment du parcours. Il fonctionne sur une copie de la collection plutôt que sur la collection d'origine.

Conclusion

Dans ce tutoriel, nous avons couvert l'itérateur en Java. Pour utiliser les itérateurs, vous devez importer la bibliothèque Java.util.*. En effet, un itérateur est une interface du package util. Ces classes de collection incluent HashMap, ArrayList, LinkedList, etc. Avec un itérateur, vous pouvez modifier ces classes de collection lors de la traversée. Les itérateurs sont également conçus pour changer facilement les collections sur lesquelles ils bouclent. La méthode 'next()' renvoie l'élément suivant, la méthode hasNext() renvoie true si nous avons l'élément suivant sinon renvoie false et la méthode remove() supprime les éléments d'une collection lors de la boucle.


Balise Java