Como usar o método Iterator para remover um elemento de uma coleção em Java?

Como Usar O Metodo Iterator Para Remover Um Elemento De Uma Colecao Em Java



O ' iterador ” oferece uma maneira segura e fácil de remover ou excluir elementos de dados específicos de uma coleção durante a iteração sobre ela. Previne a ocorrência de “ ConcurrentModificationException ” que surge quando o loop for aprimorado tenta modificar a coleção. Ele armazena o rastreamento da posição atual e oferece aos programadores a chance de avançar e remover os elementos subjacentes conforme necessário.

Este blog demonstra o processo para remover um elemento de uma coleção utilizando o método iterador.







Como usar o método Iterator para remover um elemento de uma coleção em Java?

O método iterador é unidirecional e pode ser usado com vários tipos de coleção, incluindo “ ArrayList”, “LinkedList ”, etc. Ele oferece uma maneira uniforme de remover elementos de qualquer coleção que implemente o “ Iterável ”interface.



Vamos visitar alguns exemplos para entender melhor o método iterador:



Exemplo 1: Removendo elementos específicos da coleção usando o método Iterator

O método iterador pode ser utilizado com “ se ” ou loops para selecionar os elementos especificados. E então o “ remover ()” método é usado para executar a operação de exclusão, conforme mostrado abaixo:





importar java.util.* ;
aula IterExam
{
público estático vazio principal ( Corda [ ] argumentos )
{
ArrayList < inteiro > demoArrList = novo ArrayList < inteiro > ( ) ;
para ( int eu = 0 ; eu <= vinte ; eu = eu + 2 )
{
demoArrList. adicionar ( eu ) ;
}
Iterador < inteiro > itr = demoArrList. iterador ( ) ;
Sistema . fora . println ( 'ArrayList fornecido:' ) ;

para ( int eu = 0 ; eu < demoArrList. tamanho ( ) ; eu ++ )
{
Sistema . fora . imprimir ( demoArrList. pegar ( eu ) + ' ' ) ;
}
enquanto ( itr. temPróximo ( ) )
{
se ( itr. próximo ( ) % 3 == 0 )
itr. remover ( ) ;
}
Sistema . fora . println ( ' \n Depois de remover os elementos Odd ArrayList' ) ;
para ( int eu = 0 ; eu < demoArrList. tamanho ( ) ; eu ++ )
{
Sistema . fora . imprimir ( demoArrList. pegar ( eu ) + ' ' ) ;
}
}
}

Descrição do código acima:

  • Primeiro, o ArrayList é criado e, em seguida, um múltiplo de “ 2 ” é inserido até o intervalo de “ vinte ” com a ajuda do “ para ' laço.
  • Em seguida, declare um “ iterador ” para exibir os elementos de ArrayList no console.
  • Em seguida, utilize o “ temPróximo ()” com o objeto iterador para percorrer todos os elementos ArrayList residentes.
  • Depois disso, o “ se ” é utilizada para verificar os elementos que são totalmente divisíveis por “ 3 ” dentro dele.
  • Então o ' remover ()” método é usado para deletar os elementos que são retornados pelo método “ se ' declaração.
  • No final, o ArrayList atualizado foi exibido usando o “ para ' laço.

Após a compilação:



A saída exibe os elementos específicos, que são divisíveis por três e removidos do ArrayList usando um método iterador.

Exemplo 2: Removendo todos os elementos da coleção

Para remover todos os elementos residentes da coleção, o método iterador pode ser usado junto com seu “ remover ()” como mostrado abaixo:

importar java.util.* ;
aula Vazio
{
público estático vazio principal ( Corda arg [ ] )
{
Vetor < inteiro > vetor de teste = novo Vetor < inteiro > ( ) ;
testVector. adicionar ( 18 ) ;
testVector. adicionar ( vinte e um ) ;
testVector. adicionar ( 25 ) ;
testVector. adicionar ( 27 ) ;
testVector. adicionar ( 30 ) ;

Iterador < inteiro > atravessar = testVector. iterador ( ) ;
Sistema . fora . imprimir ( 'Elementos existentes:' ) ;
enquanto ( atravessar. temPróximo ( ) )
Sistema . fora . imprimir ( atravessar. próximo ( ) + ' ' ) ;
Sistema . fora . imprimir ( ' \n O testVector contém ' + testVector. tamanho ( ) + 'elementos' ) ;
atravessar = testVector. iterador ( ) ;
enquanto ( atravessar. temPróximo ( ) )
{
Sistema . fora . imprimir ( ' \n removendo' + atravessar. próximo ( ) ) ;
atravessar. remover ( ) ;
}
Sistema . fora . println ( ' \n Agora, o testVector contém ' + testVector. tamanho ( ) + 'elementos' ) ;
}
}

Descrição do código:

  • Primeiro, declare e inicialize “ Vetor ” com valores fictícios do tipo inteiro usando o método “ adicionar ()” método.
  • Em seguida, crie um método iterador que usa o “ temPróximo ()' e ' próximo ()' métodos. Ele exibe os elementos de dados residentes e seu tamanho correspondente.
  • Em seguida, utilize o “ temPróximo ()” junto com o objeto iterador dentro da propriedade “ enquanto ' laço.
  • Depois disso, utilize o “ próximo ()” para selecionar o próximo elemento e, em seguida, o remover () é chamado para deletar cada elemento receptor.
  • Desta forma, todos os elementos do Vetor são removidos e o tamanho do Vetor é exibido no console.

Descrição do código:

O código acima confirma que todos os elementos da coleção foram removidos.

Exemplo 3: Removendo elemento usando ListIterator

O ListIterator funciona de forma semelhante ao método iterador. O ListIterator executa o deslocamento em ambos os lados nas direções para frente e para trás. Para remover elementos específicos da coleção usando o ListIterator em Java, acesse o código abaixo:

importar java.util.ArrayList ;
importar java.util.ListIterator ;
público aula ListIteratorDemo {

//Inicializando o método main()
público estático vazio principal ( Corda [ ] argumentos )
{ //Declarando e inicializando o ArrayList
ArrayList < Corda > adulto = novo ArrayList < Corda > ( ) ;
adulto adicionar ( 'Capuz' ) ;
adulto adicionar ( 'Polo' ) ;
adulto adicionar ( 'Henleys' ) ;
adulto adicionar ( 'Suor' ) ;
adulto adicionar ( 'Casual' ) ;
adulto adicionar ( 'Luxo' ) ;
adulto adicionar ( 'Dryfit' ) ;


ListIterator < Corda > litro = adulto listIterator ( ) ;
Sistema . fora . println ( 'Lista antes da remoção' ) ;
para ( int eu = 0 ; eu < adulto tamanho ( ) ; eu ++ )
Sistema . fora . imprimir ( adulto pegar ( eu ) + ' ' ) ;
enquanto ( litro. temPróximo ( ) ) {
se ( litro. próximo ( ) . é igual a ( 'Suor' ) ) {
litro. remover ( ) ;
}
}
Sistema . fora . println ( ' \n Lista após a remoção' ) ;
para ( int eu = 0 ; eu < adulto tamanho ( ) ; eu ++ )
Sistema . fora . imprimir ( adulto pegar ( eu ) + ' ' ) ;
}
}

Descrição do código acima:

  • Primeiro, declare e inicialize o ArrayList com os valores fictícios do tipo String e exiba todos os elementos no console usando o “ para ' laço.
  • Em seguida, crie um objeto que chama o método “ temPróximo ()” dentro do método “ enquanto ' laço. Ele atravessa todos os elementos residentes.
  • Então o ' se ” é usada para verificar cada elemento com um texto específico, quando esse elemento corresponder ao “ remover ()” método é chamado. Ele exclui o elemento específico do “ aArt ” chamado ArrayList.
  • No final, exiba o ArrayList modificado no console.

Após a compilação:

O instantâneo confirma que o elemento de dados especificado foi removido da coleção usando ListIterator.

Conclusão

Para remover o elemento de uma coleção, o “ remover ()” do iterador é utilizado. O iterador percorre o ArrayList para localizar os dados de destino. Uma vez encontrado o “ remover ()” é usado para remover esse elemento de dados específico. Ele oferece uma técnica padronizada em diferentes coleções e evita problemas e a ocorrência de várias exceções como “ ConcurrentModificationException ”. Junto com ele, o “ ListIterator ” também pode ser útil.