Iterador Java

Oi! Na lição de hoje, falaremos sobre Java Iterator. Imagine que você vai à biblioteca e deseja encontrar um determinado livro. Como você faz isso? Se não é ficção, existe o Sistema Decimal Dewey. Se for ficção, eles são classificados em ordem alfabética pelo sobrenome. Seja o que for que você esteja procurando, em algum momento, você terá que folhear os livros, um de cada vez, até encontrar o que está procurando. Sempre que você tem uma coleção de coisas em Java, seja ela armazenada em um Array , um ArrayList , um Queue ou um List , como você encontra um valor específico? Em algum momento, você terá que passar por cada elemento, um de cada vez. É para isso que serve um iterador Java.

O que é um iterador em Java

O que é um iterador em Java? É uma forma de olhar para cada elemento de uma coleção. E por coleção, queremos dizer qualquer coisa na classe Collection . Isso inclui:

• ArrayList
• HashSet
• LinkedHashSet
• LinkedList
• Fila de prioridade
• Vetor
• e muitos outros…

Ele também inclui as várias interfaces para essas classes, como Set , List , Queue , Dequeue e Sorted Set , para citar alguns. Iterator<E> é o método de interface pública da classe Interface Iterator<E> . Foi criado no Java 1.2 e substituiu a Enumeração como uma forma de examinar elementos sequenciais em uma coleção.

Por que você não deve usar loops for como um iterador em Java

Uma das primeiras maneiras pelas quais todos são ensinados a iterar por meio de uma coleção em Java é por um loop. Se parece com isso:

class Main {
  public static void main(String[] args) {
    int exampleArray[] = new int[10];

    //fill array with data

    for(int x = 0; x < exampleArray.length; x++) {
      System.out.println("Content of element " + x + "is: " + exampleArray[x]);
    }
  }
}

A saída seria uma lista que diz:

Content of element 0 is: 0
Content of element 1 is: 1
Content of element 2 is: 2
etc.…

Isso tem seus usos, mas o que acontecerá se a coleção não armazenar elementos em um sistema baseado em índice? Por exemplo, Set s normalmente não tem ordem. Portanto, é aconselhável abandonar a prática de usar um loop for como um iterador em Java e praticar o uso da classe Iterator<E> . Aqui estão alguns exemplos de iteradores java.

Como usar o Iterador em Java

Aqui estão alguns exemplos de como usar o iterador em Java. Ao usar a classe iteradora, há três maneiras de percorrer uma coleção. Você pode usar um loop while() , um loop for() e um loop forEach() . Observe que esse loop for é diferente daquele sobre o qual falamos antes. Aqui estão os três exemplos diferentes de iteradores java. Primeiro, vamos configurar a coleção para iterar.

import java.util.*; // imports ArrayList, Collection and Iterator

class Main {
  public static void main(String[] args) {
    Collection<String> example = new ArrayList<String>();

    example.add("Item 1");
    example.add("Item 2");
    example.add("Item 3");
    example.add("Item 4");
  }
}

Esta é uma coleção simples composta por um ArrayList para o qual carregamos quatro itens. Agora vamos ver os três métodos de uso da classe Iterator para percorrer o ArrayList .

loop while()

Iterator<String> iterator = example.iterator();

while (iterator.hasNext()) {
   System.out.println("Element Value= " + iterator.next());
}

Este loop while() usa o método booleano .hasNext() da classe Iterator para verificar se há um elemento futuro. Se a pré-condição for verdadeira, ele continua. Se retornar como falso, o loop termina. A parte principal aqui é que os métodos .hasNext() e .next() fazem uma verificação inicial do primeiro elemento. Se a Coleção estiver vazia e não houver primeiro elemento, o método retornará false para .hasNext() e lançará uma NoSuchElementException para o método .next() .

For loop

for (Iterator<String> iterator = example.iterator(); iterator.hasNext();) {
  System.out.println("Element Value= " + iterator.next());
}

Isso parece um loop for mais tradicional. Ele usa o método .hasNext() como verificação de condição e parte de alteração. A inicialização é a chamada para o Iterator.

Para: Cada loop

for (String s : example) {
  System.out.println("Element Value= " + s);
}

O loop For:Each é um loop for, mas se você não souber como lê-lo, pode ser um pouco confuso. A sintaxe de um loop For:Each é for (data_type variableName : collectionName){ body} . Este loop for:each tem algumas desvantagens. Primeiro, ele só pode percorrer a coleção em uma direção. Em segundo lugar, você precisa iterar cada elemento. Você não pode pular nenhum deles. Mas como um iterador de lista conveniente em Java, é a melhor opção. No lado positivo, o loop for:each é muito fácil de ler e, uma vez que você o conhece, é difícil errar. Se você está se perguntando qual é a saída dos três loops do iterador, eles são todos iguais:

Element Value= Item 1
Element Value= Item 2
Element Value= Item 3
Element Value= Item 4

Como usar um iterador em Java para mapas

Os mapas são uma forma popular de armazenar dados, mas como eles não estendem Collection , você não pode usar os iteradores anteriores para percorrer diretamente um mapa. Então, como você usa um iterador em Java para passar por Map s e HashMap s? Existem quatro bons métodos iteradores de mapa Java. Nós os cobriremos individualmente. Primeiro, vamos carregar um mapa com uma série de valores.

import java.util.*; //imports Map and HashMap

class Main {
  public static void main(String[] args) {
    Map<String, String> example = new HashMap<String, String>();

    example.put("alpha", "one");
    example.put("beta", "two");
    example.put("gamma", "three");

  }
}

Java Hashmap Iterator Method: forEach(action)

example.forEach((k,v) -> System.out.println("Key: "+ k + ", Value: " + v));

Este método usa uma expressão lambda para iterar. O operador lambda é o método forEach() e o corpo imprime os valores. Isso usa um operador de parâmetro múltiplo. Este é o método mais rápido e limpo para map iterator no Java 8.

Método iterador Java Hashmap: loop For:Each()

for (Map.Entry<String, String> iterate : example.entrySet()) {
  System.out.println("Key: " + iterate.getKey() + ", Value: " + iterate.getValue());
}

Isso usa a sintaxe For:Each para chamar o método entrySet() para retornar um conjunto que possui a chave e o valor como seus elementos. Além disso, ao usar o método .Entry() , os objetos são verdadeiros apenas enquanto esta iteração está ocorrendo.

Método Java Hashmap Iterator: Map.Entry<k, v>

Iterator<Map.Entry<String, String>> iterator = example.entrySet().iterator();

while(iterator.hasNext()){
  Map.Entry<String, String> element = iterator.next();
  System.out.println("Key: " + element.getKey() + ", Value: " + element.getValue());
)

Esse método novamente converte o Map em um conjunto para usar o Iterador de coleções e os métodos. Para esses três métodos iteradores, o retorno é assim:

Key: alpha, Value: one
Key: beta, Value: two
Key: gamma, Value: three
Java Hashmap Iterator Method: keySet() and values()
for (String key : example.keySet()) {
  System.out.println("Key: " + key);
}
for (String value : example.values()) {
  System.out.println("Value: " + value);
}

Este retorna os elementos de uma maneira diferente. Ele primeiro retornará todas as chaves em ordem e, em seguida, todos os valores:

Key: alpha
Key: beta
Key: gamma
Value: one
Value: two
Value: three