Un iterador en Java es uno de los más utilizados. cursores en el marco de colecciones de Java . Se utiliza para recorrer o iterar a través de elementos de una colección uno por uno.

• Se utiliza para atravesar elementos únicamente en dirección de avance.
• Elimina elementos de forma segura durante el recorrido usando remove().
• Iterator es un cursor universal que se aplica a todos los tipos de colecciones: conjunto de listas y cola.

Declaración de iterador

Iterador de interfaz pública

Aquí E representa el tipo de elementos sobre los que se va a iterar.

Creación de objetos de iterador

Un objeto Iterador se crea llamando al método iterador() en un objeto de colección. Aquí usaremos un iterador para recorrer e imprimir cada elemento en un Lista de matrices .

Recopilación nombres = nueva ArrayList <>();
Iterador itr = nombres.iterador();

   import     java.util.ArrayList  ;   import     java.util.Iterator  ;   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     {          // Create an ArrayList and add some elements      ArrayList   <  String  >     al     =     new     ArrayList   <>  ();      al  .  add  (  'A'  );      al  .  add  (  'B'  );      al  .  add  (  'C'  );      // Obtain an iterator for the ArrayList      Iterator   <  String  >     it     =     al  .  iterator  ();      // Iterate through the elements and print each one      while     (  it  .  hasNext  ())     {          // Get the next element      String     n     =     it  .  next  ();         System  .  out  .  println  (  n  );         }      }   }   

A B C  

Jerarquía del iterador

El iterador es parte del paquete java.util y es implementado por todas las clases de colección a través de sus subinterfaces.

Métodos de interfaz iterador

La interfaz del iterador define tres métodos como se enumeran a continuación:

• tieneSiguiente(): Devuelve verdadero si la iteración tiene más elementos.
• próximo(): Devuelve el siguiente elemento de la iteración. arroja Ninguna excepción de elemento tal si no hay más elementos presentes.
• eliminar(): Elimina el último elemento devuelto por next(). Este método solo se puede llamar una vez por llamada a next().

Nota : El método remove() puede generar dos excepciones, concretamente las siguientes:

Trabajo interno

En esta sección intentaremos comprender cómo funcionan internamente Java Iterator y sus métodos. Tomemos el siguiente objeto LinkedList para comprender esta funcionalidad.

Paso 1: Ahora creemos un objeto Iterador en el objeto Lista como se muestra a continuación:

Iterador ciudadesIterator = ciudades.iterator();

El iterador 'citiesIteartor' tendrá el siguiente aspecto:

Aquí el cursor del iterador apunta antes del primer elemento de la lista.

Paso 2: Ahora ejecutaremos el siguiente fragmento de código.

ciudadesIterator.hasNext();
ciudadesIterator.next();

Cuando ejecutamos el fragmento de código anterior, el cursor del iterador apunta al primer elemento de la lista como se muestra en el diagrama anterior.

Paso 3: Ahora ejecutaremos el siguiente fragmento de código.

ciudadesIterator.hasNext();
ciudadesIterator.next();

Cuando ejecutamos el fragmento de código anterior, el cursor del iterador apunta al segundo elemento de la lista como se muestra en el diagrama anterior.

Paso 4: Realice este proceso para llevar el cursor del iterador al elemento final de la lista.

Paso 5: Después de leer el elemento final, si ejecutamos el siguiente fragmento de código, devuelve un valor falso.

ciudadesIterator.hasNext();

Como el cursor del iterador apunta después del elemento final de la lista tieneSiguiente() El método devuelve un valor falso.

Nota: Java Iterator solo admite iteraciones en dirección directa, por lo que se lo conoce como cursor unidireccional. Por el contrario, ListIterator es bidireccional y permite atravesar en ambas direcciones.

Ejemplo: Aquí usaremos un iterador para recorrer y eliminar elementos impares de una ArrayList.

   import     java.util.ArrayList  ;   import     java.util.Iterator  ;   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     {          // Creating an ArrayList of Integer type      ArrayList   <  Integer  >     al     =     new     ArrayList   <>  ();      // Adding elements to the ArrayList      for     (  int     i     =     0  ;     i      <     10  ;     i  ++  )     {      al  .  add  (  i  );      }      // Printing the original list      System  .  out  .  println  (  'Original List: '     +     al  );      // Creating an Iterator for the ArrayList      Iterator   <  Integer  >     itr     =     al  .  iterator  ();      // Iterating through the list and removing odd elements      while     (  itr  .  hasNext  ())     {          // Getting the next element      int     i     =     itr  .  next  ();             System  .  out  .  print  (  i     +     ' '  );         // Removing odd elements      if     (  i     %     2     !=     0  )     {      itr  .  remove  ();      }      }      System  .  out  .  println  ();      // Printing the modified list after removal of odd elements      System  .  out  .  println  (  'Modified List: '     +     al  );      }   }   

Original List: [0 1 2 3 4 5 6 7 8 9] 0 1 2 3 4 5 6 7 8 9 Modified List: [0 2 4 6 8]  

Explicación: En el ejemplo anterior, creamos una ArrayList de números enteros, luego la iteramos usando un Iterador y eliminamos todos los números impares. Imprime la lista antes y después de eliminar los elementos impares e imprime la lista modificada solo con números pares.