Java ListIterator – ListIterator en Java

Como sabemos, Java tiene cuatro cursores: Enumeration, Iterator, ListIterator y Spliterator. Ya hemos discutido los cursores Enumeration e Iterator en mi publicación anterior. Antes de pasar por esta publicación, por favor revisa mi publicación anterior en: Java Iterator. En esta publicación, discutiremos sobre el tercer cursor de Java: ListIterator.

Java ListIterator

Al igual que Iterator, ListIterator es un Java Iterator, que se utiliza para iterar elementos uno por uno desde un objeto implementado como Lista.

• Está disponible desde Java 1.2.
• Extiende la interfaz Iterator.
• Es útil solo para clases implementadas como Lista.
• A diferencia de Iterator, soporta las cuatro operaciones: CRUD (CREATE, READ, UPDATE y DELETE).
• A diferencia de Iterator, soporta tanto iteraciones en Dirección Hacia Adelante como en Dirección Hacia Atrás.
• Es un Iterador Bidireccional.
• No tiene un elemento actual; su posición de cursor siempre se encuentra entre el elemento que sería devuelto por una llamada a previous() y el elemento que sería devuelto por una llamada a next().

NOTA:- ¿Qué son las operaciones CRUD en la API de Colecciones?

• CREAR: Agregar nuevos elementos al objeto de Colección.
• LEER: Recuperar elementos del objeto de Colección.
• ACTUALIZAR: Actualizar o establecer elementos existentes en el objeto de colección.
• ELIMINAR: Eliminar elementos del objeto de colección.

Diagrama de Clase de la Clase Java ListIterator

En Java, ListIterator es una interfaz en la API de Colecciones. Extiende la interfaz Iterator. Para admitir la iteración en dirección hacia adelante y hacia atrás y las operaciones CRUD, tiene los siguientes métodos. Podemos usar este Iterador para todas las clases implementadas de List, como ArrayList, CopyOnWriteArrayList, LinkedList, Stack, Vector, etc. Exploraremos estos métodos en profundidad con algunos métodos útiles en las secciones siguientes.

Métodos de Java ListIterator

La interfaz Java ListIterator tiene los siguientes métodos.

• void add(E e): Inserta el elemento especificado en la lista.
• boolean hasNext(): Devuelve true si este iterador de lista tiene más elementos al recorrer la lista en dirección hacia adelante.
• boolean hasPrevious(): Devuelve true si este iterador de lista tiene más elementos al recorrer la lista en dirección hacia atrás.
• E next(): Returns the next element in the list and advances the cursor position.
• int nextIndex(): Devuelve el índice del elemento que se devolvería en una llamada posterior a next().
• E previous(): Returns the previous element in the list and moves the cursor position backwards.
• int previousIndex(): Devuelve el índice del elemento que se devolvería en una llamada posterior a previous().
• void remove(): Elimina de la lista el último elemento que fue devuelto por next() o previous().
• void set(E e): Reemplaza el último elemento devuelto por next() o previous() con el elemento especificado.

Exploraremos estos métodos uno por uno con ejemplos útiles en las secciones siguientes.

Ejemplo Básico de Java ListIterator

En esta sección, discutiremos algunos métodos de ListIterator con ejemplos. Primero, necesitamos entender cómo obtener este objeto iterador. ¿Cómo obtener ListIterator?

ListIterator<E> listIterator()

Devuelve un iterador de lista sobre los elementos de esta lista. Ejemplo:-

import java.util.*;

public class ListIteratorDemo 
{
  public static void main(String[] args) 
  {
	List();
	names.add("Rams");
	names.add("Posa");
	names.add("Chinni");
		
	// Obteniendo ListIterator
	ListIterator<String> namesIterator = names.listIterator();
	
	// Recorriendo elementos
	while(namesIterator.hasNext()){
	   System.out.println(namesIterator.next());			
	}	

	// El bucle mejorado crea un Iterador Interno aquí.
	for(String name: names){
	   System.out.println(name);			
	}	
  }
}

Salida:-

Rams
Posa
Chinni

Ejemplo de Iteración Bidireccional con ListIterator

En esta sección, exploraremos cómo funcionan los métodos de ListIterator para realizar iteraciones en dirección hacia adelante y hacia atrás.

import java.util.*;

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

Salida:-

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

Tipos de Iteradores en Java

Como sabemos, Java tiene cuatro cursores: Enumeration, Iterator, ListIterator y Spliterator. Podemos categorizarlos en dos tipos principales como se muestra a continuación:

• Iteradores Uni-Directional
  Son cursores que admiten solo iteraciones en dirección hacia adelante. Por ejemplo, Enumeration, Iterator, etc., son Iteradores Uni-Directional.- Iteradores Bi-Directional
  Son cursores que admiten tanto iteraciones en dirección hacia adelante como en dirección hacia atrás. Por ejemplo, ListIterator es un Iterador Bi-Directional.

Cómo funciona internamente Java ListIterator?

Como sabemos, Java ListIterator funciona en ambas direcciones, lo que significa que funciona tanto en dirección hacia adelante como en dirección hacia atrás. Es un Iterador Bi-direccional. Para admitir esta funcionalidad, tiene dos conjuntos de métodos.

• Métodos de Iteración en Dirección Adelante
  Necesitamos utilizar los siguientes métodos para admitir la Iteración en Dirección Adelante:

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

• Métodos de Iteración en Dirección Atrás
  Necesitamos utilizar los siguientes métodos para admitir la Iteración en Dirección Atrás:

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

En mi publicación anterior, ya hemos discutido cómo funciona internamente un Iterator en la dirección hacia adelante en la sección “¿Cómo funciona internamente el Iterator de Java?” Incluso ListIterator también funciona de esa manera. Si desea revisar mi publicación anterior, haga clic aquí: Java Iterator. En esta sección, discutiremos cómo funciona ListIterator en la Dirección Atrás. Tomemos el siguiente objeto LinkedList para entender esta funcionalidad.

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

Ahora cree un objeto ListIterator en LinkedList como se muestra a continuación:

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

Supongamos que el ListIterator “namesIterator” se ve así: Aquí, el Cursor del ListIterator apunta antes del primer elemento de la Lista. Ahora ejecutamos el siguiente fragmento de código en el bucle while.

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

Cuando ejecutamos el fragmento de código anterior en el bucle while, el Cursor del ListIterator apunta al último elemento en el LinkedList. Luego, podemos ejecutar el siguiente fragmento de código para comenzar a recorrer desde el final hacia el principio.

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

Cuando ejecutamos el fragmento de código anterior, el cursor de ListIterator apunta al “penúltimo” elemento en la Lista, como se muestra en el diagrama anterior. Realice este proceso para llevar el cursor de ListIterator al primer elemento de la LinkedList. Después de leer el primer elemento, si ejecutamos el siguiente fragmento de código, devuelve el valor “false”.

namesIterator.hasPrevious();

Como el cursor de ListIterator apunta al elemento antes del primer elemento de la LinkedList, el método hasPrevious() devuelve un valor falso. Después de observar todos estos diagramas, podemos decir que Java ListIterator admite iteraciones en ambas direcciones, como se muestra en los diagramas a continuación. Por lo tanto, también se conoce como un cursor bidireccional. Dirección Forward de ListIterator Dirección Backward de ListIterator

Ventajas de ListIterator

A diferencia de Iterator, ListIterator tiene las siguientes ventajas:

• Al igual que Iterator, admite operaciones de lectura y eliminación.
• También admite operaciones de creación y actualización.
• Eso significa que admite operaciones CRUD: operaciones de CREAR, LEER, ACTUALIZAR y ELIMINAR.
• Admite tanto la iteración en dirección hacia adelante como en dirección hacia atrás. Eso significa que es un Cursor Java Bidireccional.
• Los nombres de los métodos son simples y fáciles de usar.

Limitaciones de ListIterator

En comparación con Iterator, Java ListIterator tiene muchas ventajas. Sin embargo, aún tiene algunas limitaciones siguientes.

• Es una implementación de lista solo de clases de implementación de Iterator.
• A diferencia de Iterator, no es aplicable para toda la API de Colecciones.
• No es un Cursor Java Universal.
• En comparación con Spliterator, NO admite la iteración paralela de elementos.
• En comparación con Spliterator, NO ofrece un mejor rendimiento para iterar un gran volumen de datos.

Similitudes entre Iterator y ListIterator

En esta sección, discutiremos las similitudes entre dos Cursores Java: Iterator y ListIterator.

• Ambos fueron introducidos en Java 1.2.
• Ambos son Iteradores utilizados para iterar elementos de una Colección o Lista.
• Ambos admiten operaciones de LEER y ELIMINAR.
• Ambos admiten la iteración en dirección hacia adelante.
• Ambos no son interfaces heredadas.

Diferencias entre Iterator y ListIterator

En esta sección, discutiremos las diferencias entre dos iteradores de Java: Iterator y ListIterator.

Eso es todo acerca de ListIterator en Java. Espero que estas teorías y ejemplos de Java ListIterator te ayuden a comenzar con la programación de ListIterator. Referencia: Documentación de la API de ListIterator