Introdução ao Iterator em Java
Um iterador é uma interface usada para buscar elementos um por um em uma coleção. Está disponível no pacote Java chamado Java. pacote util. A API de coleta implementa o método iterator () e, portanto, os dados podem ser recuperados de interfaces como Map, List, Queue, Deque e Set, todas implementadas na estrutura de coleta. Como o nome sugere, um iterador em Java itera através de uma coleção de objetos.
Sintaxe:
Iterator iterator()
Abaixo do iterador, está o nome de um objeto criado, chamando o método iterator () da interface de coleção. "Coleção" é o nome do objeto de coleção.
Iterator iter = collection.iterator();
Métodos de Iterador em Java
Os iteradores têm 4 métodos em Java que são usados para percorrer as coleções e recuperar as informações necessárias. Eles são os seguintes:
- hasNext (): este é um método que retorna boolean true se a iteração tiver um próximo elemento presente e boolean false se não houver nenhum elemento presente a seguir.
- next (): este método retorna o valor do elemento presente na próxima iteração. Suponha que não haja elementos a serem retornados na próxima iteração e, em seguida, um "NoSuchElementException" será lançado.
- remove (): esse método remove o elemento presente retornado pelo iterador da coleção. Caso este método seja chamado anterior ao método next (), ele lança "IllegalStateException".
- forEachRemaining (): este método executa a operação em todos os elementos restantes na coleção até que todos tenham sido processados ou até que uma exceção seja lançada. Além disso, este é um método recentemente introduzido pela Oracle Corporation em seu lançamento do Java SE 8.
Exemplo de Iterador em Java
Abaixo está o exemplo do Iterator em Java:
Código:
import java.io.*;
import java.util.*;
public class IteratorExample (
public static void main(String() args)
(
ArrayList val = new ArrayList();
val.add("Iteration started");
val.add("Printing iteration1");
val.add("Printing iteration2");
val.add("Printing iteration3");
val.add("End of iteration");
// Iterates through the list
Iterator iter = val.iterator();
System.out.println("The values of iteration are as follows: ");
while (iter.hasNext())
System.out.println(iter.next() + " ");
System.out.println();
)
)
Resultado:
Exceções lançadas pelos métodos Iterator
Em uma lista de elementos, um iterador pode buscar informações apenas nos elementos existentes. Ele trava ou gera uma exceção se tentar acessar um elemento que não está presente na próxima iteração. Aqui, conheceremos os diferentes tipos de exceções que obtemos ao implementar os métodos do iterador.
1. método next ()
Ao iterar através de um conjunto de elementos e buscá-los por esse método, a seguinte exceção pode ocorrer.
- NoSuchElementException: isso ocorre se next () tenta recuperar um elemento que não existe na lista atual. Portanto, sempre é necessário usar um hasNext () antes de chamar next ().
2. método remove ()
Existem 2 tipos de exceções que podem ocorrer aqui:
- IllegalStateException: se o método remove () for chamado antes do método next (), essa exceção será lançada. Isso ocorre porque o método tenta remover um elemento que ainda não foi especificado pelo método next () e, portanto, falha. Para resolver essa exceção, next () deve ser chamado para se referir ao primeiro item e, em seguida, remove () pode ser chamado para remover o mesmo da lista.
- UnsupportedOperationException: essa exceção geralmente é lançada ao tentar modificar um objeto de lista adicionando ou removendo uma operação que não suporta modificação. Por exemplo, quando uma matriz é tentada a converter em uma lista por Arrays.asList lança essa exceção. Isso ocorre porque o objeto List terá um tamanho fixo, pois é criado pelo wrapper de ArrayList e, portanto, a modificação não será permitida. Para resolver esse problema, converta o objeto Arrays.asList em ArrayList ou LinkedList antes de executar operações como adicionar / remover no mesmo.
Sintaxe:
//ArrayList is created from the list having fixed size
list = new ArrayList(list);
Iterator iter = list.iterator();
while(iter.hasNext())(
if( iter.next().equals("First iteration") )(
iter.remove();
)
)
Métodos de ListIterator
Esses métodos permitem que o iterador percorra as duas direções do objeto de coleção. A seguir estão alguns deles:
- add (): este método insere o valor do objeto fornecido e é retornado quando o método next () é chamado.
- hasNext (): esse método é igual ao mencionado nos tipos de iteradores que retornam Boolean true / false dependendo do próximo elemento ter um valor ou não.
- hasPrevious (): esse método é oposto a hasNext () e retorna Boolean true se a lista tiver um elemento anterior e vice-versa.
- next (): este método recupera o próximo elemento da lista fornecida.
- previous (): este método recupera o elemento anterior da lista.
- remove (): Isso exclui o elemento atual da lista. Quando esse método é chamado antes da função next () ou previous (), ele lança "IllegalStateException".
Exemplo para ListIterator
Abaixo está um exemplo em ArrayList para ListIterator.
Código:
import java.util.*;
public class IteratorExample (
public static void main(String args()) (
// Creating an array list
ArrayList array = new ArrayList();
// add elements to the array list
array.add("First element");
array.add("Second element");
array.add("Third element");
array.add("Fourth element");
array.add("Fifth element");
array.add("Sixth element");
// Displaying elements of an array
System.out.println("Printing input of the array: ");
Iterator iter = array.iterator();
while(iter.hasNext()) (
Object value = iter.next();
System.out.println(value + " ");
)
System.out.println();
// To update the elements of iteration
ListIterator listiter = array.listIterator();
while(listiter.hasNext()) (
Object value = listiter.next();
listiter.set(value + "+");
)
System.out.print("Updated array elements are as follows: ");
iter = array.iterator();
while(iter.hasNext()) (
Object value = iter.next();
System.out.print(value + " ");
)
System.out.println("\n");
// To display the contents in backward direction
System.out.println("Printing elements in backward direction: ");
while(listiter.hasPrevious()) (
Object value = listiter.previous();
System.out.print(value + " ");
)
System.out.println();
)
)
Resultado:
Vantagens dos Iteradores em Java
Abaixo estão as vantagens dos Iteradores:
- Ele suporta todas as classes na interface Collection.
- Os métodos de um iterador são bastante simples e fáceis de entender e implementar.
- Os elementos de uma coleção podem ser facilmente modificados (adicionar / remover) usando Iteradores.
- O acesso a elementos por meio de Iteradores não resultará em exceções em tempo de execução.
- O tratamento de dados é eficiente.
- Ele pode iterar sobre várias variáveis simultaneamente, mantendo o estado de iteração de cada variável separadamente.
Limitações dos Iteradores em Java
Abaixo estão as limitações dos Iteradores:
- O iterador Java pode iterar apenas em uma direção, ou seja, na direção direta.
- Ele não pode ser usado para iterar entre duas estruturas de dados diferentes simultaneamente.
- Não pode ser usado para rastrear um elemento.
- Ele não permite a modificação da estrutura do elemento que está sendo iterado, uma vez que armazena sua posição.
- Pode ser ineficiente em certos casos, atravessar os elementos diretamente é mais eficiente.
Conclusão
Iteradores são o método mais comumente usado para recuperar elementos da interface de coleção. É chamado de Universal Java Cursor, pois é aplicável a todas as classes de coleção.
Artigo recomendado
Este é um guia para o Iterator em Java. Aqui discutimos métodos e exemplos de Iterator em Java, juntamente com suas limitações e vantagens. Você também pode consultar nossos outros artigos sugeridos para saber mais -
- Introdução ao Heap Sort em Java
- Substituindo em Java (Exemplos)
- Iteradores em C # com vantagens e desvantagens
- As 10 principais perguntas da entrevista sobre a coleção Java
- Jogue vs Joga | As 5 principais diferenças que você deve saber