Um Iterador em Java é um dos mais comumente usados cursores no Java Collections Framework . É usado para percorrer ou iterar os elementos de uma coleção, um por um.

• É usado para percorrer elementos apenas na direção direta.
• Remove elementos com segurança durante a travessia usando remove().
• Iterator é um cursor universal que se aplica a todos os tipos de coleção – Conjunto de listas e Fila.

Declaração do Iterador

Iterador de interface pública

Aqui E representa o tipo de elementos a serem iterados.

Criação de Objeto do Iterador

Um objeto Iterator é criado chamando o método iterator() em um objeto de coleção. Aqui usaremos um Iterator para percorrer e imprimir cada elemento em um ListaArray .

Coleção nomes = novo ArrayList <>();
Iterador itr = nomes.iterator();

   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  

Hierarquia do Iterador

O iterador faz parte do pacote java.util e é implementado por todas as classes de coleção através de suas subinterfaces.

Métodos de interface do iterador

A interface do iterador define três métodos listados abaixo:

• hasNext(): Retorna verdadeiro se a iteração tiver mais elementos.
• próximo(): Retorna o próximo elemento na iteração. Isso joga NoSuchElementException se nenhum outro elemento estiver presente.
• remover(): Remove o último elemento retornado por next(). Este método pode ser chamado apenas uma vez por chamada para next().

Observação : o método remove() pode gerar duas exceções, a saber:

Trabalho Interno

Nesta seção tentaremos entender como o Java Iterator e seus métodos funcionam internamente. Vamos pegar o seguinte objeto LinkedList para entender essa funcionalidade.

Etapa 1: Agora vamos criar um objeto Iterator no objeto List conforme mostrado abaixo:

Iterador cidadesIterator = cidades.iterator();

O iterador 'citiesIteartor' terá a seguinte aparência:

Aqui o Cursor do Iterador está apontando antes do primeiro elemento da Lista.

Etapa 2: Agora executaremos o seguinte trecho de código.

cidadesIterator.hasNext();
cidadesIterator.next();

Quando executamos o trecho de código acima, o Cursor do Iterator aponta para o primeiro elemento da lista, conforme mostrado no diagrama acima.

Etapa 3: Agora executaremos o seguinte trecho de código.

cidadesIterator.hasNext();
cidadesIterator.next();

Quando executamos o trecho de código acima, o Cursor do Iterator aponta para o segundo elemento da lista, conforme mostrado no diagrama acima.

Etapa 4: Faça este processo para chegar ao Cursor do Iterador até o elemento final da Lista.

Etapa 5: Depois de ler o elemento final, se executarmos o trecho de código abaixo, ele retornará um valor falso.

cidadesIterator.hasNext();

Como o Cursor do Iterador aponta para após o elemento final da Lista temPróximo() método retorna um valor falso.

Observação: Java Iterator suporta apenas iteração de direção direta, por isso é conhecido como cursor unidirecional. Em contraste, ListIterator é bidirecional, permitindo a travessia em ambas as direções.

Exemplo: Aqui usaremos um Iterator para percorrer e remover elementos ímpares de um 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]  

Explicação: No exemplo acima, criamos um ArrayList de inteiros e, em seguida, iteramos por ele usando um Iterator e removemos todos os números ímpares. Imprime a lista antes e depois de remover os elementos ímpares e imprime a lista modificada apenas com números pares.