Enumeración vs Iterator vs ListIterator en Java

La enumeración es una interfaz. Se utiliza en el marco de la colección en Java para recuperar los elementos uno por uno. La enumeración es una interfaz heredada que se aplica solo para clases heredadas como Vector , HashTable , Stack , etc. Proporciona una iteración de una sola dirección. Al usar la enumeración, solo podemos realizar la operación de lectura y no podemos realizar la operación de eliminación.

El objeto de enumeración se puede crear llamando al método elements() presente en la clase Vector.

// Here "v" is a vector object. enum is of
// type Enumeration interface and refers to "v"
Enumeration enum = v.elements();

Un iterador es un cursor universal que se puede aplicar a cualquier objeto de colección. Proporciona una iteración de una sola dirección. Al usar un iterador, podemos realizar operaciones de lectura y eliminación, pero no podemos realizar operaciones de reemplazo. 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 clases implementadas de la interfaz Map .

El objeto Iterator se puede crear llamando al método iterator() presente en la interfaz Collection

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

ListIterator es el cursor más poderoso entre los tres cursores. ListIterator solo es aplicable para clases implementadas en listas como ArrayList , LinkedList , Stack , etc. ListIterator atraviesa tanto en dirección hacia adelante como hacia atrás. Al usar ListIteartor, podemos realizar operaciones de lectura, eliminación y reemplazo. El ListIterator debe usarse cuando queremos enumerar elementos de la lista.

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

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

Java

// A Java program to demonstrates the 
// difference between Enumeration,
// Iterator, and ListIterator
  
import java.io.*;
import java.util.*;
  
class GFG {
      
    public static void main(String args[])
    {
          
        // Creating a vector object
        Vector<Integer> v = new Vector<Integer>();
          
        // Adding elements to the vector object
        v.add(10);
        v.add(20);
        v.add(30);
        v.add(40);
        v.add(50);
          
        System.out.println("Enumeration: ");
          
        // Creating an Enumeration object
        Enumeration e = v.elements();
          
        // Checking the next element availability
        while (e.hasMoreElements()) {
              
            // Moving cursor to the next element
            int i = (Integer)e.nextElement();
              
            // Printing the element
            System.out.print(i + " ");
        }
        System.out.println();
        System.out.println();
          
        System.out.println("Iterator: ");
          
        // Creating Iterator object
        Iterator<Integer> itr = v.iterator();
          
        // Checking the next element availability
        while (itr.hasNext()) {
              
            // Moving cursor to the next element
            int i = (Integer)itr.next();
              
            // Checking if i == 10 then
            // remove the element
            if (i == 10)
                itr.remove();
        }
        System.out.println(v);
        System.out.println();
          
        System.out.println("ListIterator: ");
          
        // Creating ListIterator object
        ListIterator<Integer> ltr = v.listIterator();
          
        // Checking the next element availability
        while (ltr.hasNext()) {
              
            // Moving cursor to the next element
            int i = (Integer)ltr.next();
              
            // Performing add, remove, and 
            // replace operation
            if (i == 20)
                ltr.remove();
              
            else if (i == 30)
                ltr.add(60);
              
            else if (i == 40)
                ltr.set(100);
        }
          
        System.out.println(v);
    }
}

Producción

Enumeration: 
10 20 30 40 50 

Iterator: 
[20, 30, 40, 50]

ListIterator: 
[30, 60, 100, 50]

Tabla que muestra la diferencia entre enumeración, iterador y ListIterator

Propiedad	Enumeración	iterador	ListIterator
1. ¿Dónde podemos aplicar?	Solo se puede aplicar a las clases heredadas.	Se puede aplicar a cualquier interfaz de colección.	Se puede aplicar a la única interfaz de lista.
2. ¿Es un legado?	Sí (introducido en 1,0 V).	No (introducido en 1,2 V).	No (introducido en 1,2 V).
3. Movimiento Permitido	Dirección única, es decir, podemos atravesar los elementos presentes en la colección solo en la dirección de avance.	Dirección única, es decir, podemos atravesar los elementos presentes en la colección solo en la dirección de avance.	Bidireccional, es decir, podemos atravesar los elementos presentes en la colección tanto hacia delante como hacia atrás.
4. Operación permitida	Solo podemos realizar la operación de lectura.	Podemos realizar operaciones de lectura y eliminación.	Podemos realizar operaciones de lectura, eliminación, adición y reemplazo.
5. ¿Cómo podemos conseguirlo?	Llamando al método de elements() presente en la clase de vector.	Llamando al método iterator() presente en cualquier interfaz de colección.	Llamando al método listIterator() presente en la interfaz de la lista.

Publicación traducida automáticamente

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

Java

Deja una respuesta Cancelar la respuesta