Java ListIterator – ListIterator en Java

Comme nous le savons, Java dispose de quatre curseurs : Énumération, Itérateur, ListIterator et Spliterator. Nous avons déjà discuté des curseurs Énumération et Itérateur dans mon précédent article. Avant de continuer avec ce post, veuillez consulter mon précédent article à l’adresse suivante : Java Itérateur. Dans ce post, nous discuterons du troisième curseur Java : ListIterator.

Java ListIterator

Tout comme l’Itérateur, le ListIterator est un Itérateur Java, utilisé pour itérer les éléments un par un à partir d’un objet implémenté en tant que liste.

• Il est disponible depuis Java 1.2.
• Il étend l’interface Itérateur.
• Il est utile uniquement pour les classes implémentées en tant que liste.
• Contrairement à l’Itérateur, il prend en charge les quatre opérations : CRUD (CREATE, READ, UPDATE et DELETE).
• Contrairement à l’Itérateur, il prend en charge les itérations dans les deux sens : avant et arrière.
• C’est un Itérateur bidirectionnel.
• Il n’a pas d’élément courant ; sa position de curseur se situe toujours entre l’élément qui serait retourné par un appel à previous() et l’élément qui serait retourné par un appel à next().

NOTE : Quelles sont les opérations CRUD dans l’API Collection ?

• CREATE : Ajout de nouveaux éléments à un objet Collection.
• READ : Récupération des éléments d’un objet Collection.
• MISE À JOUR: Mise à jour ou configuration d’éléments existants dans l’objet Collection.
• SUPPRIMER: Suppression d’éléments de l’objet Collection.

Diagramme de classe de la classe Java ListIterator

En Java, ListIterator est une interface dans l’API Collection. Elle étend l’interface Iterator. Pour prendre en charge l’itération dans les directions avant et arrière ainsi que les opérations CRUD, elle dispose des méthodes suivantes. Nous pouvons utiliser cet itérateur pour toutes les classes implémentées de List telles que ArrayList, CopyOnWriteArrayList, LinkedList, Stack, Vector, etc. Nous explorerons ces méthodes en profondeur avec quelques méthodes utiles dans les sections suivantes.

Méthodes de ListIterator en Java

L’interface ListIterator en Java dispose des méthodes suivantes.

• void add(E e): Insère l’élément spécifié dans la liste.
• boolean hasNext(): Renvoie true si cet itérateur de liste a plus d’éléments lors de la traversée de la liste dans la direction avant.
• boolean hasPrevious(): Renvoie true si cet itérateur de liste a plus d’éléments lors de la traversée de la liste dans la direction arrière.
• E next(): Returns the next element in the list and advances the cursor position.
• int nextIndex(): Renvoie l’index de l’élément qui serait retourné par un appel ultérieur à next().
• E previous(): Returns the previous element in the list and moves the cursor position backwards.
• int previousIndex(): Renvoie l’index de l’élément qui serait retourné par un appel ultérieur à previous().
• void remove(): Supprime de la liste le dernier élément retourné par next() ou previous().
• void set(E e): Remplace le dernier élément retourné par next() ou previous() par l’élément spécifié.

Nous explorerons ces méthodes une par une avec des exemples utiles dans les sections suivantes.

Exemple de base de l’itérateur de liste Java

Dans cette section, nous discuterons de certaines méthodes de l’itérateur de liste avec quelques exemples. Tout d’abord, nous devons comprendre comment obtenir cet objet d’itérateur. Comment obtenir un ListIterator ?

ListIterator<E> listIterator()

Cela renvoie un itérateur de liste sur les éléments de cette liste. Exemple :-

import java.util.*;

public class ListIteratorDemo 
{
  public static void main(String[] args) 
  {
	List();
	names.add("Rams");
	names.add("Posa");
	names.add("Chinni");
		
	// Obtention de ListIterator
	ListIterator<String> namesIterator = names.listIterator();
	
	// Parcours des éléments
	while(namesIterator.hasNext()){
	   System.out.println(namesIterator.next());			
	}	

	// La boucle améliorée crée ici un itérateur interne.
	for(String name: names){
	   System.out.println(name);			
	}	
  }
}

Résultat :-

Rams
Posa
Chinni

Exemple d’itération bidirectionnelle avec ListIterator

Dans cette section, nous explorerons comment les méthodes de ListIterator fonctionnent pour effectuer des itérations dans les deux sens, en avant et en arrière.

import java.util.*;

public class BiDirectinalListIteratorDemo 
{
	public static void main(String[] args) 
	{
		List();
		names.add("Rams");
		names.add("Posa");
		names.add("Chinni");
		
		// Obtenir ListIterator
		ListIterator<String> listIterator = names.listIterator();
		
		// Parcourir les éléments
		System.out.println("Forward Direction Iteration:");
		while(listIterator.hasNext()){
			System.out.println(listIterator.next());			
		}	
		
		// Parcourir les éléments, the iterator is at the end at this point
		System.out.println("Backward Direction Iteration:");
		while(listIterator.hasPrevious()){
			System.out.println(listIterator.previous());			
		}
	}
}

Sortie :-

Forward Direction Iteration:
Rams
Posa
Chinni
Backward Direction Iteration:
Chinni
Posa
Rams

Types d’itérateurs Java

Comme nous le savons, Java a quatre curseurs : Enumeration, Iterator, ListIterator et Spliterator. Nous pouvons les catégoriser en deux types principaux comme indiqué ci-dessous :

• Itérateurs unidirectionnels
  Ce sont des curseurs qui ne prennent en charge que les itérations en avant. Par exemple, Enumeration, Iterator, etc. sont des itérateurs unidirectionnels.- Itérateurs bidirectionnels
  Ce sont des curseurs qui prennent en charge les itérations dans les deux sens, en avant et en arrière. Par exemple, ListIterator est un itérateur bidirectionnel.

Comment fonctionne le ListIterator Java en interne ?

Comme nous le savons, ListIterator Java fonctionne dans les deux sens, c’est-à-dire en avant et en arrière. C’est un itérateur bidirectionnel. Pour prendre en charge cette fonctionnalité, il dispose de deux ensembles de méthodes.

• Méthodes d’itération dans le sens avant
  Nous devons utiliser les méthodes suivantes pour prendre en charge l’itération dans le sens avant :

1. hasNext())
2. next()
3. nextIndex()

• Méthodes d’itération dans le sens arrière
  Nous devons utiliser les méthodes suivantes pour prendre en charge l’itération dans le sens arrière :

1. hasPrevious()
2. previous()
3. previousIndex()

Dans mon précédent article, nous avons déjà discuté du fonctionnement interne d’un itérateur dans le sens avant dans la section « Comment fonctionne un itérateur Java en interne ? ». Même ListIterator fonctionne de la même manière. Si vous souhaitez consulter mon précédent article, cliquez ici : Java Iterator. Dans cette section, nous allons discuter du fonctionnement de ListIterator dans le sens arrière. Prenons l’objet LinkedList suivant pour comprendre cette fonctionnalité.

List<String> names = new LinkedList<>();
names.add("E-1");
names.add("E-2");
names.add("E-3");
.
.
.
names.add("E-n");

Créez maintenant un objet ListIterator sur LinkedList comme indiqué ci-dessous :

ListIterator<String> namesIterator = names.listLterator();

Supposons que « namesIterator » ListIterator ressemble à cela : Ici, le curseur de ListIterator pointe avant le premier élément de la liste. Exécutons maintenant le code suivant dans la boucle while.

namesIterator.hasNext();
namesIterator.next();

Lorsque nous exécutons le code ci-dessus dans la boucle while, le curseur de ListIterator pointe vers le dernier élément de LinkedList. Ensuite, nous pouvons exécuter le code suivant pour commencer à parcourir de la fin vers le début.

namesIterator.hasPrevious();
namesIterator.previous();

Lorsque nous exécutons le extrait de code ci-dessus, le curseur de ListIterator pointe vers l’élément « Dernier mais un » dans la liste comme indiqué dans le diagramme ci-dessus. Effectuez ce processus pour atteindre le curseur de ListIterator au premier élément de LinkedList. Après avoir lu le premier élément, si nous exécutons le extrait de code ci-dessous, il renvoie la valeur « faux ».

namesIterator.hasPrevious();

Comme le curseur de ListIterator pointe avant le premier élément de LinkedList, la méthode hasPrevious() renvoie une valeur « faux ». Après avoir observé tous ces diagrammes, nous pouvons dire que ListIterator Java prend en charge les itérations dans les deux sens, comme indiqué dans les diagrammes ci-dessous. Il est donc également connu sous le nom de curseur bidirectionnel. Itération dans le sens avant de ListIterator Itération dans le sens arrière de ListIterator

Avantages de ListIterator

Contrairement à l’itérateur, ListIterator présente les avantages suivants:

• Tout comme l’itérateur, il prend en charge les opérations de LECTURE et de SUPPRESSION.
• Il prend également en charge les opérations de CRÉATION et de MISE À JOUR.
• Cela signifie qu’il prend en charge les opérations CRUD : CREATE, READ, UPDATE et DELETE.
• Il prend en charge à la fois l’itération dans le sens avant et dans le sens arrière. Cela signifie que c’est un curseur Java bidirectionnel.
• Les noms des méthodes sont simples et faciles à utiliser.

Limitations de ListIterator

Comparé à l’itérateur, le ListIterator Java présente de nombreux avantages. Cependant, il présente encore certaines limitations suivantes.

• C’est une implémentation de liste uniquement pour les classes d’itérateur.
• Contrairement à l’itérateur, il n’est pas applicable à toute l’API Collection.
• Ce n’est pas un curseur Java universel.
• Comparé à Spliterator, il ne prend PAS en charge l’itération parallèle des éléments.
• Comparé à Spliterator, il ne prend PAS en charge de meilleures performances pour itérer de grandes quantités de données.

Similitudes entre Iterator et ListIterator

Dans cette section, nous discuterons des similitudes entre les deux curseurs Java : Iterator et ListIterator.

• Les deux ont été introduits dans Java 1.2.
• Les deux sont des itérateurs utilisés pour itérer les éléments d’une collection ou d’une liste.
• Les deux prennent en charge les opérations READ et DELETE.
• Les deux prennent en charge l’itération dans le sens avant.
• Les deux ne sont pas des interfaces héritées.

Différences entre Iterator et ListIterator

Dans cette section, nous discuterons des différences entre les deux itérateurs Java : Iterator et ListIterator.

C’est tout ce qu’il y a à savoir sur ListIterator en Java. J’espère que ces théories et exemples sur ListIterator en Java vous aideront à vous lancer dans la programmation avec ListIterator. Référence : Documentation de l’API ListIterator