Itérateur en Java-javaDidacticiel-php.cn

Un Iterator est une interface utilisée pour récupérer les éléments un par un dans une collection. Il est disponible dans un package Java appelé Java. paquet util. L'API de collection implémente la méthode iterator() et, par conséquent, les données peuvent être récupérées à partir d'interfaces telles que Map, List, Queue, Deque et Set, qui sont toutes implémentées à partir du framework de collection. Comme son nom l'indique, un itérateur en Java parcourt une collection d'objets.

Syntaxe :

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Iterator<E> iterator()

Copier après la connexion

Sous l'itérateur se trouve le nom d'un objet créé en appelant la méthode iterator() de l'interface de collection. "collection" est le nom de l'objet de collection.

Iterator iter = collection.iterator();

Copier après la connexion

Méthodes d'itérateur en Java

Les itérateurs ont 4 méthodes en Java qui sont utilisées pour parcourir les collections et récupérer les informations requises. Ils sont les suivants :

hasNext() : Il s'agit d'une méthode qui renvoie un booléen vrai si l'itération a un élément suivant présent et un booléen faux s'il n'y a aucun élément présent ensuite.
next (): Cette méthode renvoie la valeur de l'élément présente dans l'itération à venir. Supposons qu'aucun élément ne soit renvoyé lors de l'itération suivante, alors une « NoSuchElementException » est levée.
remove() : Cette méthode supprime l'élément présent renvoyé par l'itérateur de la collection. Dans le cas où cette méthode est appelée avant la méthode next(), elle renvoie « IllegalStateException ».
forEachRemaining() : Cette méthode exécute tous les éléments restants de la collection jusqu'à ce qu'ils aient été traités ou jusqu'à ce qu'une exception soit levée. Il s'agit également d'une méthode nouvellement introduite par Oracle Corporation dans sa version Java SE 8.

Exemple d'itérateur en Java

Ci-dessous l'exemple d'Iterator en Java :

Code :

import java.io.*;
import java.util.*;
public class IteratorExample {
public static void main(String[] args)
{
ArrayList<String> val = new ArrayList<String>();
val.add("Iteration started");
val.add("Printing iteration1");
val.add("Printing iteration2");
val.add("Printing iteration3");
val.add("End of iteration");
// Iterates through the list
Iterator iter = val.iterator();
System.out.println("The values of iteration are as follows: ");
while (iter.hasNext())
System.out.println(iter.next() + " ");
System.out.println();
}
}

Copier après la connexion

Sortie :

Itérateur en Java

Les méthodes itératrices génèrent des exceptions

Dans une liste d'éléments, un itérateur ne peut récupérer des informations que sur les éléments existants. Par conséquent, il plantera ou lancera une exception s’il tente d’accéder à un élément qui n’est pas présent dans l’itération suivante. Ici, nous apprendrons à connaître les différents types d'exceptions que nous obtenons lors de l'implémentation des méthodes itératives.

1. méthode next()

En parcourant un ensemble d'éléments et en les récupérant par cette méthode.

NoSuchElementException : Cela se produit si next() tente de récupérer un élément qui n'existe pas dans la liste actuelle. Par conséquent, un hasNext() doit toujours être utilisé avant d'appeler next().

2. Méthode Remove()

Il existe 2 types d'exceptions qui peuvent survenir ici :

IllegalStateException : Si la méthode remove() est appelée avant la méthode next(), alors cette exception est levée. En effet, la méthode tente de supprimer un élément qui n'est pas encore spécifié par la méthode next() et échoue donc. Pour résoudre cette exception, next() doit être appelé pour faire référence au premier élément, puis Remove() peut être appelé pour le supprimer de la liste.
UnsupportedOperationException : Cette exception est généralement levée lors de la modification d'un objet de liste en ajoutant ou en supprimant une opération qui ne prend pas en charge la modification. Par exemple, lorsqu'un tableau est tenté de se convertir en liste par Arrays.asList lève cette exception. En effet, l'objet List aura une taille fixe lorsque le wrapper le crée à partir de ArrayList, et par conséquent, la modification ne sera pas autorisée. Pour résoudre ce problème, convertissez l'objet Arrays.asList en objet ArrayList ou LinkedList avant d'effectuer des opérations telles que l'ajout/la suppression sur celui-ci.

Syntaxe :

//ArrayList is created from the list having fixed size
list = new ArrayList<String>(list);
Iterator<String> iter = list.iterator();
while(iter.hasNext()){
if( iter.next().equals("First iteration") ){
iter.remove();
}
}

Copier après la connexion

Méthodes de ListIterator

Ces méthodes permettent à l'itérateur de parcourir dans les deux sens l'objet de collection. En voici quelques-uns :

add(): This method inserts the object value given and is returned when the next() method is called.
hasNext(): This method is the same as the one mentioned in iterator types, which returns Boolean true/false depending on the next element having a value or not.
hasPrevious(): This method is opposite to hasNext() and returns Boolean true if the list has a previous element and vice versa.
next(): This method retrieves the next element from the given list.
previous(): This method retrieves the previous element from the list.
remove(): This deletes the present element from the list. When this method is called either before the next() or previous() function, it throws “IllegalStateException”.

Example for ListIterator

Below is an example in ArrayList for ListIterator.

Code:

import java.util.*;
public class IteratorExample {
public static void main(String args[]) {
// Creating an array list
ArrayList array = new ArrayList();
// add elements to the array list
array.add("First element");
array.add("Second element");
array.add("Third element");
array.add("Fourth element");
array.add("Fifth element");
array.add("Sixth element");
// Displaying elements of an array
System.out.println("Printing input of the array: ");
Iterator iter = array.iterator();
while(iter.hasNext()) {
Object value = iter.next();
System.out.println(value + " ");
}
System.out.println();
// To update the elements of iteration
ListIterator listiter = array.listIterator();
while(listiter.hasNext()) {
Object value = listiter.next();
listiter.set(value + "+");
}
System.out.print("Updated array elements are as follows: ");
iter = array.iterator();
while(iter.hasNext()) {
Object value = iter.next();
System.out.print(value + " ");
}
System.out.println("\n");
// To display the contents in backward direction
System.out.println("Printing elements in backward direction: ");
while(listiter.hasPrevious()) {
Object value = listiter.previous();
System.out.print(value + " ");
}
System.out.println();
}
}

Copier après la connexion

Output:

Itérateur en Java

Advantages of Iterators in Java

Below are the advantages of Iterators:

It supports all classes under the Collection interface.
The methods of an iterator are quite simple and easy to understand and implement.
Elements of a Collection can be easily modified (add/remove) using Iterators.
Accessing elements through Iterators will not lead to run-time exceptions.
Data handling is efficient.
It can iterate over various variables concurrently by holding each variable’s state of iteration separately.

Limitations of Iterators in Java

Below are the limitations of Iterators:

Java iterator can iterate only in one direction, i.e. forward direction.
It cannot be used to iterate between two different data structures concurrently.
It cannot be used to backtrace an element.
It does not allow modification of the structure of the element being iterated as it stores its position.
It might be inefficient in certain cases were traversing through the elements directly is more efficient.

Conclusion

Iterators are the most commonly used method to retrieve elements from the collection interface. It is called Universal Java Cursor as it is applicable across all the Collection classes.