Un curseur Java est un itérateur utilisé pour parcourir, parcourir ou récupérer les éléments d'un objet Collection ou Stream un par un. Dans cet article, nous découvrirons les itérateurs Java et leur fonctionnement.

Types de curseurs en Java

Il y a trois curseurs en Java comme mentionné ci-dessous :

1. Itérateur
2. Énumération
3. ListItérateur

Note: SplitIterator peut également être considéré comme un curseur car il s'agit uniquement d'un type d'itérateur.

1. Itérateur

Les itérateurs en Java sont utilisés dans le Cadre de collecte pour récupérer les éléments un par un. C'est un universel itérateur car nous pouvons l’appliquer à n’importe quel objet Collection. En utilisant Iterator, nous pouvons effectuer à la fois des opérations de lecture et de suppression. Il s'agit d'une version améliorée d'Enumeration avec la fonctionnalité supplémentaire de suppression d'un élément.

Iterator doit être utilisé chaque fois que nous souhaitons énumérer des éléments dans toutes les interfaces implémentées du framework Collection telles que Set, List, Queue, Deque et toutes les classes implémentées de l'interface Map. L'itérateur est le seulement curseur disponible pour l’ensemble du framework de collection. Un objet itérateur peut être créé en appelant le itérateur() méthode présente dans l’interface Collection.

Syntaxe

Iterator itr = c.  iterator  ();>

Note: Ici, c est n’importe quel objet Collection. itr est de type Iterator interface et fait référence à c.

mapper l'itérateur java

Méthodes d’interface itérateur en Java

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

1. hasNext() : Renvoie vrai si l'itération comporte plus d'éléments.

public boolean hasNext();>

2. suivant() : Renvoie l'élément suivant dans l'itération. Ça jette NoSuchElementException si aucun autre élément n'est présent.

public Object next();>

3. supprimer() : Supprime l'élément suivant dans l'itération. Cette méthode ne peut être appelée qu'une seule fois par appel à next().

public void remove();>

Note: retirer() La méthode peut lever deux exceptions, à savoir les suivantes :

• UnsupportedOperationException : Si l'opération de suppression n'est pas prise en charge par cet itérateur
• IllegalStateException : Si la méthode suivante n’a pas encore été appelée ou si la méthode Remove a déjà été appelée après le dernier appel à la méthode suivante.

Comment fonctionne l’itérateur Java en 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é.

List cities = new LinkedList();  cities.add('G-1');  cities.add('G-2');  cities.add('G-3');  .  .  .  cities.add('G-n');>

Maintenant, créons un objet Iterator sur l'objet List comme indiqué ci-dessous :

Iterator citiesIterator = cities.iterator();>

L’itérateur cityIteartor ressemblera à ceci :

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

Maintenant, nous allons exécuter l'extrait de code suivant.

citiesIterator.hasNext(); citiesIterator.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.

nbsp

Maintenant, nous allons exécuter l'extrait de code suivant.

citiesIterator.hasNext(); citiesIterator.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. Effectuez ce processus pour atteindre le curseur de l'itérateur jusqu'à l'élément final de la liste.

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

citiesIterator.hasNext();>

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

Note: Après avoir observé tous ces diagrammes, nous pouvons dire que Java Iterator ne prend en charge que l'itération vers l'avant, comme indiqué dans le diagramme ci-dessous. Il est donc également connu sous le nom de curseur unidirectionnel.

Exemple

// Java program to Demonstrate Iterator // Importing ArrayList and Iterator classes // from java.util package import java.util.ArrayList; import java.util.Iterator; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating an ArrayList class object // Declaring object of integer type ArrayList al = nouvelle liste de tableaux (); // Itération sur la liste pour (int i = 0; i< 10; i++) al.add(i); // Printing the elements in the List System.out.println(al); // At the beginning itr(cursor) will point to // index just before the first element in al Iterator itr = al.iterator(); // Vérification de l'élément suivant où // la condition est vraie jusqu'à ce qu'il y ait un seul élément // dans la liste en utilisant la méthode hasnext() while (itr.hasNext()) { // Déplacement du curseur vers l'élément suivant int i = itr.next( ); // Récupération des éléments un par un System.out.print(i + ' '); // Suppression des éléments impairs if (i % 2 != 0) itr.remove(); } // Commande pour la ligne suivante System.out.println(); // Impression des éléments à l'intérieur de l'objet System.out.println(al); } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9 [0, 2, 4, 6, 8]>

SplitItérateur

Les splitérateurs, comme les autres itérateurs, servent à parcourir les éléments d'une source. Une source peut être un Collection , un canal IO ou une fonction de générateur. Il est inclus dans JDK 8 pour prendre en charge un parcours parallèle efficace (programmation parallèle) en plus du parcours séquentiel. L'interface Java Spliterator est un itérateur interne qui divise le flux en parties plus petites. Ces petites pièces peuvent être traitées en parallèle.

Note: Dans la programmation réelle, nous n’aurons peut-être jamais besoin d’utiliser directement Spliterator. Dans des opérations normales, il se comportera exactement de la même manière que Java Iterator.

Avantages de l'itérateur Java

• Nous pouvons l'utiliser pour n'importe quelle classe Collection.
• Il prend en charge les opérations READ et REMOVE.
• Il s'agit d'un curseur universel pour l'API de collection.
• Les noms de méthodes sont simples et faciles à utiliser.

Limites de l'itérateur Java

En outre, il existe certaines limitations d'Iterator qui sont répertoriées comme suit :

• Dans les opérations CRUD, il ne prend PAS en charge les opérations CREATE et UPDATE.
• Il ne prend en charge que les itérations de direction avant qui sont un itérateur unidirectionnel.
• Comparé à Spliterator, il ne prend PAS en charge les éléments itératifs parallèles, ce qui signifie qu'il ne prend en charge que l'itération séquentielle.
• Comparé à Spliterator, il ne prend PAS en charge de meilleures performances pour itérer de gros volumes de données.

2. Énumération

C'est une interface utilisée pour récupérer des éléments de collections héritées (Vector, Hashtable). L'énumération est le premier itérateur présent dans le JDK 1.0, les silences sont inclus dans le JDK 1.2 avec plus de fonctionnalités. Les énumérations sont également utilisées pour spécifier les flux d'entrée vers un SéquenceInputStream . Nous pouvons créer un objet Enumeration en appelant éléments() méthode de la classe vectorielle sur n'importe quel objet vectoriel

Syntaxe

// Here 'v' is an Vector class object. e is of // type Enumeration interface and refers to 'v' Enumeration e =   v  .  elements  ();>

Il y a deux méthodes dans l'interface Enumération à savoir :

1. public booléen hasMoreElements() : Cette méthode teste si cette énumération contient plus d'éléments ou non.

2. Objet public nextElement() : Cette méthode renvoie l'élément suivant de cette énumération. Il lève NoSuchElementException si aucun autre élément n'est présent

Exemple

// Java program to demonstrate Enumeration // Importing Enumeration and Vector classes // from java.util package import java.util.Enumeration; import java.util.Vector; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating a vector object Vector v = new Vector(); // Iterating over vector object for (int i = 0; i < 10; i++) v.addElement(i); // Printing elements in vector object System.out.println(v); // At beginning e(cursor) will point to // index just before the first element in v Enumeration e = v.elements(); // Checking the next element availability where // condition holds true till there is a single // element // remaining in the List while (e.hasMoreElements()) { // Moving cursor to next element int i = (Integer)e.nextElement(); // Print above elements in object System.out.print(i + ' '); } } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9>

Il existe certaines limites au dénombrement qui sont les suivantes :

• L'énumération est pour héritage classes (Vector, Hashtable) uniquement. Ce n’est donc pas un itérateur universel.
• Les opérations de suppression ne peuvent pas être effectuées à l’aide de l’énumération.
• Seule l’itération dans le sens avant est possible.

Similitudes entre l'énumération Java et l'itérateur

• Les deux sont des curseurs Java.
• Les deux sont utilisés pour parcourir une collection d’éléments d’objet un par un.
• Les deux prennent en charge l’opération READ ou Retrieval.
• Les deux sont des curseurs Java unidirectionnels, ce qui signifie qu’ils ne prennent en charge que l’itération vers l’avant.

Différences entre l'énumération Java et l'itérateur

Le tableau suivant décrit les différences entre Java Enumeration et Iterator :

3. ListItérateur

Il ne s'applique qu'aux classes implémentées par la collection List telles que ArrayList, LinkedList, etc. Il fournit une itération bidirectionnelle. ListIterator doit être utilisé lorsque nous voulons énumérer des éléments de List. Ce curseur a plus de fonctionnalités (méthodes) que d'itérateur. L'objet ListIterator peut être créé en appelant listItérateur() méthode présente dans l’interface List.

Syntaxe

ListIterator ltr = l.  listIterator  ();>

Note: Ici, l est n'importe quel objet List, ltr est de type. Interface ListIterator et fait référence à l. L'interface ListIterator étend l'interface Iterator. Ainsi, les trois méthodes de l'interface Iterator sont disponibles pour ListIterator. De plus, il y a six plus de méthodes.

1. Direction vers l'avant

1.1 hasNext() : Renvoie vrai si l'itération contient plus d'éléments

public boolean hasNext();>

1.2 suivant() : Identique à la méthode next() de Iterator. Renvoie l'élément suivant dans l'itération.

public Object next();>

1.3 nextIndex() : Renvoie l'index de l'élément suivant ou la taille de la liste si l'itérateur de liste est à la fin de la liste.

public int nextIndex();>

2. Direction arrière

2.1 hasPrevious() : Renvoie vrai si l’itération contient plus d’éléments lors du déplacement vers l’arrière.

public boolean hasPrevious();>

2.2 précédent() : Renvoie l'élément précédent dans l'itération et peut lancer NoSuchElementException si plus aucun élément n'est présent.

public Object previous();>

2.3 indexprécédent() : Renvoie l'index de l'élément précédent ou -1 si l'itérateur de liste est au début de la liste,

âge de Pete Davidson

public int previousIndex();>

3. Autres méthodes

3.1 supprimer() : Identique à la méthode Remove() de Iterator. Supprime l'élément suivant dans l'itération.

public void remove();>

Ensemble 3.2 (objet obj) : Remplace le dernier élément renvoyé par next() ou previous() par l'élément spécifié.

public void set(Object obj);>

3.3 ajouter (Objet obj) : Insère l'élément spécifié dans la liste à la position précédant l'élément qui serait renvoyé par next()

public void add(Object obj);>

De toute évidence, les trois méthodes qui ListItérateur hérite de l'itérateur ( aSuivant() , suivant() , et retirer() ) faites exactement la même chose dans les deux interfaces. Le hasPrécédent() et les opérations précédentes sont des analogues exacts de aSuivant() et suivant() . Les premières opérations font référence à l'élément avant le curseur (implicite), tandis que la seconde fait référence à l'élément après le curseur. L'opération précédente déplace le curseur vers l'arrière, tandis que la suivante le fait avancer.

ListIterator n'a aucun élément actuel ; la position de son curseur se situe toujours entre l'élément qui serait renvoyé par un appel à précédent() et l'élément qui serait renvoyé par un appel à suivant().

1 jeu() la méthode peut lever 4 exceptions.

• Exception d'opération non prise en charge : si l'opération set n'est pas prise en charge par cet itérateur de liste
• ClassCastException : Si la classe de l'élément spécifié empêche son ajout à cette liste
• Exception d'argument illégal: Si un aspect de l'élément spécifié empêche son ajout à cette liste
• IllegalStateException : Si ni next ni previous n'ont été appelés, ou si delete ou add n'ont pas été appelés après le dernier appel à next ou previous

2. ajouter() la méthode peut lever 3 exceptions.

• Exception d'opération non prise en charge : Si la méthode add n'est pas prise en charge par cet itérateur de liste
• ClassCastException : Si la classe de l'élément spécifié empêche son ajout à cette liste
• Exception d'argument illégal: Si un aspect de cet élément empêche son ajout à cette liste

Exemple

// Java program to demonstrate ListIterator // Importing ArrayList and List iterator classes // from java.util package import java.util.ArrayList; import java.util.ListIterator; // Main class public class Test { // Main driver method public static void main(String[] args) { // Creating an object of ArrayList class ArrayList al = new ArrayList(); // Iterating over Arraylist object for (int i = 0; i < 10; i++) // Adding elements to the Arraylist object al.add(i); // Print and display all elements inside object // created above System.out.println(al); // At beginning ltr(cursor) will point to // index just before the first element in al ListIterator ltr = al.listIterator(); // Checking the next element availability while (ltr.hasNext()) { // Moving cursor to next element int i = (Integer)ltr.next(); // Getting even elements one by one System.out.print(i + ' '); // Changing even numbers to odd and // adding modified number again in // iterator if (i % 2 == 0) { // Change to odd i++; // Set method to change value ltr.set(i); // To add ltr.add(i); } } // Print and display statements System.out.println(); System.out.println(al); } }>

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9 [1, 1, 1, 3, 3, 3, 5, 5, 5, 7, 7, 7, 9, 9, 9]>

Note: De même, il existe certaines limitations avec ListIterator . C'est l'itérateur le plus puissant, mais il n'est applicable qu'aux classes implémentées par List, ce n'est donc pas un itérateur universel.

Les points importants

1. Veuillez noter qu'au départ, toute référence d'itérateur pointera vers l'index juste avant l'index du premier élément d'une collection.
2. Nous ne créons pas d'objets Enumeration, Iterator, ListIterator car ce sont des interfaces. Nous utilisons des méthodes comme elements(), iterator(), listIterator() pour créer des objets. Ces méthodes ont un nom anonyme Classe intérieure qui étend les interfaces respectives et renvoie cet objet de classe.

Note: Le $ Le symbole dans le nom de la classe de référence est une preuve que le concept de classes internes est utilisé et que ces objets de classe sont créés.

char en int

Cela peut être vérifié par le code ci-dessous. Pour en savoir plus sur la classe interne, reportez-vous

// Java program to demonstrate iterators references // Importing required classes from java.util package import java.util.Enumeration; import java.util.Iterator; import java.util.ListIterator; import java.util.Vector; // Main class public class GFG { // Main driver method public static void main(String[] args) { // Creating an object of Vector class Vector v = new Vector(); // Creating three iterators Enumeration e = v.elements(); Iterator itr = v.iterator(); ListIterator ltr = v.listIterator(); // Print class names of iterators // using getClass() and getName() methods System.out.println(e.getClass().getName()); System.out.println(itr.getClass().getName()); System.out.println(ltr.getClass().getName()); } }>

java.util.Vector java.util.Vector$Itr java.util.Vector$ListItr>

Explication

En Java, un itérateur est une interface utilisée pour parcourir une collection d’objets un par un. Il est utilisé pour parcourir toute structure de données basée sur une collection, y compris les tableaux, les listes, les ensembles et les cartes.

Un itérateur dispose de trois méthodes principales utilisées pour parcourir la collection :

• hasNext() – Cette méthode vérifie s’il existe un autre élément dans la collection qui peut être itéré.
• next() – Cette méthode renvoie l'élément suivant de la collection.
• remove() – Cette méthode supprime l'élément actuel de la collection.
  

L'interface Iterator fait partie de Java Collection Framework et est implémentée par les classes qui représentent les différents types de collections.

Programme

import java.util.ArrayList; import java.util.Iterator; public class IteratorExample { public static void main(String[] args) { ArrayListnoms = nouvelle ArrayList(); noms.add('Alice'); noms.add('Bob'); noms.add('Charlie'); noms.add('David'); // Création d'un itérateur pour la liste de noms Itérateuritérateur = noms.iterator(); // Itération sur la liste des noms à l'aide de l'itérateur while (iterator.hasNext()) { String name = iterator.next(); System.out.println(nom); } } }>

Alice Bob Charlie David>

Dans cet exemple, nous avons créé une ArrayList de chaînes et lui avons ajouté quatre noms. Nous avons ensuite créé un itérateur pour la liste en utilisant la méthode iterator() de la classe ArrayList. Nous avons utilisé la méthode hasNext() pour vérifier s'il y a plus d'éléments dans la liste sur lesquels parcourir, et la méthode next() pour obtenir l'élément suivant dans la liste. Nous avons imprimé chaque élément en utilisant la méthode System.out.println().

Utiliser un itérateur pour parcourir une collection est un moyen pratique et efficace de parcourir la collection car il permet de parcourir la collection sans connaître la structure interne de la collection. Il permet également de supprimer des éléments de la collection lors d'une itération.

Avantages de l'itérateur en Java :

• L'Iterator est une interface simple et facile à utiliser qui nous permet de parcourir une collection sans exposer son implémentation sous-jacente.
• L'Iterator est un moyen efficace de parcourir une collection, en particulier lorsque nous disposons d'une grande quantité de données.
• L'Iterator fournit un moyen sûr de supprimer des éléments d'une collection pendant une itération sans provoquer d'exceptions de modification simultanées.
• L'interface Iterator est implémentée par toutes les classes de collection en Java, nous pouvons donc utiliser le même code pour parcourir différents types de collections.

Inconvénients de l'itérateur en Java :

L'utilisation d'Iterator en Java présente certains inconvénients, comme mentionné ci-dessous :

• L'Iterator est une interface unidirectionnelle, ce qui signifie que nous ne pouvons avancer que dans une collection. Nous ne pouvons pas revenir en arrière ou sauter à un élément spécifique.
• L'Iterator n'est pas thread-safe, nous ne pouvons donc pas l'utiliser pour parcourir une collection dans un environnement multithread sans une synchronisation appropriée.
• L'Iterator ne fournit aucun mécanisme pour modifier les éléments lors d'une itération sur une collection, mis à part la suppression d'éléments. Si nous devons modifier des éléments, nous devons utiliser d'autres interfaces comme ListIterator ou une simple boucle for.