Diferencia entre un iterador y ListIterator en Java

iterador

Los iteradores se utilizan en el marco de la colección en Java para recuperar elementos uno por uno. Se puede aplicar a cualquier objeto de colección. Al usar Iterator, podemos realizar operaciones de lectura y eliminación. El iterador debe usarse siempre que queramos enumerar elementos en todas las interfaces implementadas del marco de la colección como Set , List , Queue , Deque y también en todas las clases implementadas de la interfaz Map . Iterator es el único cursor disponible para todo el marco de la colección.

El objeto iterador se puede crear llamando al método iterator() presente en la interfaz de colección.

// Here "c" is any Collection object. itr is of
// type Iterator interface and refers to "c"
Iterator itr = c.iterator();

ListIterator
Solo se aplica alas clases implementadas de la colección List , como arraylist , linkedlist , etc. Proporciona iteración bidireccional. ListIterator debe usarse cuando queremos enumerar elementos de List. Este cursor tiene más funcionalidad (métodos) que el iterador.

El objeto ListIterator se puede crear llamando al método listIterator() presente en la interfaz List.

// Here "l" is any List object, ltr is of type
// ListIterator interface and refers to "l"
ListIterator ltr = l.listIterator();

Diferencias entre Iterator y ListIterator:

Iterator puede atravesar solo en dirección hacia adelante, mientras que ListIterator atraviesa tanto en dirección hacia adelante como hacia atrás.

Ejemplo:

import java.io.*;
import java.util.*;
  
class IteratorDemo1 {
    public static void main(String[] args)
    {
        ArrayList<Integer> list
            = new ArrayList<Integer>();
  
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
  
        // Iterator
        Iterator itr = list.iterator();
  
        System.out.println("Iterator:");
        System.out.println("Forward traversal: ");
  
        while (itr.hasNext())
            System.out.print(itr.next() + " ");
  
        System.out.println();
  
        // ListIterator
        ListIterator i = list.listIterator();
  
        System.out.println("ListIterator:");
        System.out.println("Forward Traversal : ");
  
        while (i.hasNext())
            System.out.print(i.next() + " ");
  
        System.out.println();
  
        System.out.println("Backward Traversal : ");
  
        while (i.hasPrevious())
            System.out.print(i.previous() + " ");
  
        System.out.println();
    }
}

Producción:

Iterator:
Forward traversal: 
1 2 3 4 5 

ListIterator:
Forward Traversal : 
1 2 3 4 5 
Backward Traversal : 
5 4 3 2 1

ListIterator puede ayudar a reemplazar un elemento mientras que Iterator no puede.

Ejemplo:

import java.util.ArrayList;
import java.util.ListIterator;
  
public class ListIteratorDemo2 {
    public static void main(String[] args)
    {
  
        ArrayList<Integer> aList
            = new ArrayList<Integer>();
        aList.add(1);
        aList.add(2);
        aList.add(3);
        aList.add(4);
        aList.add(5);
  
        System.out.println("Elements of ArrayList: ");
        for (Integer i : aList) {
            System.out.println(i);
        }
        ListIterator<Integer> l
            = aList.listIterator();
        l.next();
        l.set(80000);
  
        System.out.println("\nNow the ArrayList"
                           + " elements are: ");
        for (Integer i : aList) {
            System.out.println(i);
        }
    }
}

Producción:

Elements of ArrayList: 
1
2
3
4
5

Now the ArrayList elements are: 
80000
2
3
4
5

PRODUCCIÓN

Tabla que muestra la diferencia entre Iterator y ListIterator

iterador	ListIterator
Puede atravesar elementos presentes en la colección solo en la dirección de avance.	Puede atravesar elementos presentes en la Colección tanto en dirección hacia adelante como hacia atrás.
Ayuda a recorrer Mapa, Lista y Conjunto.	Solo puede atravesar List y no los otros dos.
Los índices no se pueden obtener utilizando Iterator.	Tiene métodos como nextIndex() y previousIndex() para obtener índices de elementos en cualquier momento mientras recorre List.
No se pueden modificar ni reemplazar elementos presentes en la Colección	Podemos modificar o reemplazar elementos con la ayuda de set(E e)
No se pueden agregar elementos y arroja ConcurrentModificationException.	Puede agregar fácilmente elementos a una colección en cualquier momento.
Ciertos métodos de Iterator son next(), remove() y hasNext().	Ciertos métodos de ListIterator son next(), previous(), hasNext(), hasPrevious(), add(E e).

Publicación traducida automáticamente

Artículo escrito por kartikgoel1999 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta