Interfaz de iterador en Java

La interfaz Java Iterator de las colecciones Java nos permite acceder a los elementos de la colección y se utiliza para iterar sobre los elementos de la colección ( mapa , lista o conjunto ). Ayuda a recuperar fácilmente los elementos de una colección y realizar operaciones en cada elemento. Iterator es un iterador universal, ya que se puede aplicar a cualquier objeto de colección. Podemos atravesar solo en la dirección de avance usando el iterador. Usando ListIterator que extiende Iterator, puede atravesar en ambas direcciones. Tanto leer como eliminarlas operaciones pueden ser realizadas por la interfaz del iterador. Esto está incluido en Java JDK 1.2. La única enumeración es el primer iterador que se incluye en JDK 1.0. Para usar un iterador, debemos importar el paquete java.util .

Limitaciones de la interfaz de enumeración:

Se utiliza una interfaz Iterator en lugar de Enumeration en Java Collection. 

• La enumeración no es un iterador universal y se usa solo para clases heredadas como Vector , Hashtable .
• Iterator permite a la persona que llama eliminar elementos de la colección dada durante la iteración sobre los elementos.
• Solo la iteración de dirección directa es posible en una Enumeración .

Declaración de interfaz de iterador

public interface Iterator<E>

E : el tipo de elementos devueltos por este iterador

Subinterfaces de Iterator

Iterador de eventos: 

public interface EventIterator extends Iterator<Event>

Los iteradores de eventos son

public interface ListIterator<E> extends Iterator<E>

Un iterador para listas que permite recorrer la lista en dirección hacia adelante o hacia atrás o modificar la lista durante la iteración y obtener la posición actual del iterador. ListIterator no tiene ningún elemento actual.

PrimitiveIterator<T,T_CONS>, PrimitiveIterator.OfInt, PrimitiveIterator.OfLong

Implementación de clases:

• BeanContextSupport.BCSIterator
• EventReaderDelegateEventReaderDelegate
• Escáner

Ejemplo: Implementación de Iterator

Todas las clases en Collection Framework proporcionan el método iterator() que devuelve la instancia de Iterator para iterar sobre los elementos de esa colección.

// Java program to show the usage of Iterator()
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class JavaIteratorExample1 {
    public static void main(String[] args)
    {
          // create a list
        List<String> list = new LinkedList<>();
        list.add("Welcome");
        list.add("to");
        list.add("GFG");
  
        System.out.println("The list is given as : "
                           + list);
            
          // get the iterator on the list
        Iterator<String> itr = list.iterator();
  
        // Returns true if there are more number of
        // elements.
        while (itr.hasNext()) {
            // Returns the next element.
            System.out.println(itr.next());
        }
  
        // Removes the last element.
        itr.remove();
        System.out.println(
            "After the remove() method is called : "
            + list);
    }
}

The list is given as : [Welcome, to, GFG]
Welcome
to
GFG
After the remove() method is called : [Welcome, to]

Ejemplo de iterador ArrayList

// Java program to iterate over an arraylist
// using Iterator
import java.util.*;
class GFG {
    public static void main(String[] args)
    {
        // initializing ArrayList
        List<Integer> numbers
            = Arrays.asList(10, 20, 30, 40, 50, 60, 70, 80);
  
        // Looping ArrayList using Iterator
        Iterator it = numbers.iterator();
        while (it.hasNext())
            System.out.print(it.next() + " ");
    }
}

10 20 30 40 50 60 70 80 

Desarrollar un iterador de clase personalizado

Para proporcionar una funcionalidad similar para la clase personalizada/definida por el usuario, debemos seguir los pasos a continuación:

• Defina una clase personalizada.
• Defina la clase de colección para esta clase personalizada.
• La clase de colección debe importar el paquete java.util e implementar una interfaz iterable .
• Esta clase de colección ahora debería proporcionar implementación al método iterator() de la interfaz Iterable.

Ejemplo de código de desarrollo de clase personalizada:

// java program to show the creation of
// custom class that implements iterable interface
import java.util.*;
import java.io.*;
class Employees implements Iterable {
  
    List<String> str = null;
    public Employees()
    {
        str = new ArrayList<String>();
        str.add("practice");
        str.add("geeks");
        str.add("for");
        str.add("geeks");
        str.add("to");
        str.add("learn");
        str.add("coding");
    }
  
    // if we are implementing Iterable interface, the we
    // need to define the iterator() method of Iterable
    // interface
    @Override public Iterator<String> iterator()
    {
        return str.iterator();
    }
}
  
public class EmployeesTester {
    public static void main(String[] args)
    {
        Employees emps = new Employees();
        for (String st : emps.str) {
            System.out.println(st);
        }
    }
}

practice
geeks
for
geeks
to
learn
coding

Usando el método remove() para eliminar elementos de una colección

• Elimina el último elemento de la colección devuelto por el iterador.
• Si la iteración está en curso y, mientras tanto, se modifica la colección subyacente, llamando al método remove() , un iterador lanzará una excepción ConcurrentModificationException.

// java program to remove()
// elements from a collection
  
import java.util.ArrayList;
import java.util.Iterator;
  
public class MyClass {
    public static void main(String[] args)
    {
          // create a list of Integers
        ArrayList<Integer> numbers
            = new ArrayList<Integer>();
        numbers.add(12);
        numbers.add(8);
        numbers.add(2);
        numbers.add(23);
            
          // get the iterator on the list
        Iterator<Integer> it = numbers.iterator();
        while (it.hasNext()) {
                
              // gives the next element
              // and iterator moves to next 
              // element
            Integer i = it.next();
  
            if (i < 10) {
                    
                  // removes the current element
                it.remove(); 
            }
        }
        System.out.println(numbers);
    }
}

[12, 23]

Ejemplo de iterador forEachRemaining()

// Java program to show the usage of
// Iterator forEachRemaining()
import java.util.*;
class GFG {
    public static void main(String[] args)
    {
        //  initializing ArrayList
        List<Integer> numbers
            = Arrays.asList(10, 20, 30, 40, 50, 60, 70, 80);
  
        numbers.iterator().forEachRemaining(
            System.out::println);
    }
}

10
20
30
40
50
60
70
80

Ventajas del iterador de Java:

1. No es una interfaz heredada y puede atravesar colecciones generales como ArrayList , HashMap , TreeSet , HashSet , etc.
2. Se puede usar para cualquier colección de Java y, por lo tanto, se conoce como Universal Cursor for Collection API.
3. Se admiten las operaciones de lectura y eliminación.
4. Nombres de métodos simples y fáciles de usar.

Limitaciones del iterador de Java:

1. No es compatible con las operaciones Crear y Actualizar en operaciones CRUD (Crear, Leer, Actualizar, Eliminar).
2. Solo admite recorrido unidireccional, es decir, en dirección de reenvío.
3. No admite una mejor iteración en un gran volumen de datos en comparación con Spliterator .
4. Solo admite la iteración secuencial, es decir, no admite la iteración de elementos en paralelo.

Diferencia entre iterador y enumeración:

Métodos: