Existem duas maneiras de remover objetos do ArrayList em Java, primeiro, usando o método remove (), e segundo usando Iterator. O ArrayList fornece o método de remoção sobrecarregado (), um índice de aceitação do objeto a ser removido, ou seja, remover (int índice), e outro objeto de aceitação a ser removido, ou seja, remover(objeto obj). Regra geral é, se você conhece o índice do objeto, então use o primeiro método, caso contrário use o segundo método. A propósito, você deve se lembrar de usar métodos de remoção de ArrayList, apenas quando você não está iterando sobre ArrayList se você está iterando, em seguida, usar Iterator.remove () method, failing to do so may result in ConcurrentModificationException in Java. Outro apanhado pode ter ocorrido devido ao autoboxing. Se você olhar de perto que dois métodos de remoção, remover (int índice) e remover(objeto obj) são indistinguíveis se você está tentando remover de um ArrayList de inteiros.suponha que você tem três objetos em listras, i.e., e você quer remover o segundo objeto, que é 2. Você pode chamar remove (2), que é na verdade uma chamada para remover(objeto) se considerar autoboxing, mas será interpretado como uma chamada para remover o terceiro elemento, interpretando como remove(índice).
I have discussed this problem earlier in my article about best practices to follow while overloading methods in Java. Por causa da regra de alargamento menos conhecida e autoboxing, o método mal sobrecarregado pode criar muita ambiguidade.

Code Example To Remove Elements from ArrayList

Let’s test above theory with a simple code example of ArrayList with Integers. Seguindo o programa tem uma lista de inteiros contendo 1, 2 e 3 i.e., isto corresponde exatamente ao índice.

package test; import java.util.ArrayList; importar java.util.Lista;/** * * @author http://java67.blogspot.com */public class JavaTutorial{ /** * @param args argumentos de linha de comandos */ public static void main(String args) { List<Integer> numbers = new ArrayList<Integer>(); números.adicionar (1); números.adicionar (2); números.add (3); System.as.println ("ArrayList contains:" + numbers); // Calling remove(index) numbers.remove(1); //Removendo objeto no índice 1, ou seja, o segundo objeto, que é 2 //chamando remover números (objeto).remover (3);}} saída:a lista contém : excepção no tópico "main" java.idioma.IndexOutOfBoundsException: Index: 3, Size: 2 at java.util.ArrayList.rangeCheck(ArrayList.java: 635) at java.util.ArrayList.remover(listado.java: 474) at test.Teste.main (teste.java: 33) resultado Java: 1

você pode ver que a segunda chamada também é tratada como remove (índice). A melhor maneira de remover a ambiguidade é eliminar o autoboxing e fornecer um objeto real, como mostrado abaixo.

System.as.println ("ArrayList Before:" + numbers);// Calling remove (index)numbers.remove(1); //Removendo objeto no índice 1, ou seja, o segundo objeto, que é 2 //chamando remover números (objeto).remove(novo inteiro (3));Sistema.as.println ("ArrayList After:" + numbers);Output :ArrayList Before : ArrayList After : 

This time, it works, but I am afraid of lazy developers like me, which takes autoboxing granted. Agora vamos dar uma olhada em remover o objeto do ArrayList enquanto iterando sobre eles. Você deve estar familiarizado com Iterator em Java, antes de prosseguir.

Remover o Objeto De ArrayList usando o Iterator

Este é, na verdade, um sutil detalhe de programação em Java, não é óbvio para iniciantes, como o compilador não vai reclamar, mesmo se você usar o remove() método do java.util.ArrayList, enquanto usa Iterator. Você só vai perceber o seu erro, quando você vê ConcurrentModificationException, que em si é enganador e você pode passar incontáveis horas encontrando outro tópico, que está modificando esse ArrayList, por causa da palavra concorrente. Vejamos um exemplo.

public static void main(String args) { List<Integer> numbers = new ArrayList<Integer>(); números.adicionar (101); números.adicionar (200); números.adicionar (301); números.adicionar (400); Sistema.as.println ("lista anterior:" + números); Iterator<Integer> itr = numbers.iterator(); // remove all even numbers while (itr.hasNext()) { Integer number = itr.next(); if (number % 2 == 0) { numbers.remove(number); } } System.out.println("ArrayList After : " + numbers); }Output :ArrayList Before : Exception in thread "main" java.util.ConcurrentModificationException at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859) at java.util.ArrayList$Itr.next(ArrayList.java:831) at Testing.main(Testing.java:28)

Pode ConcurrentModificationException, due to call to remove () method from ArrayList. Isto é fácil em exemplos simples como este, mas em projeto real, pode ser realmente difícil. Agora, para corrigir esta excepção, basta substituir a chamada de números.remover () à itr.remove (), isto irá remover o objecto actual que está a iterar, como mostrado abaixo :

System.as.println ("ArrayList Before:" + numbers);Iterator<inteiro> itr = numbers.iterator (); / / remove todos os números pares (itr.hasNext ()) {número inteiro = itr.proximo(); se (número % 2 == 0) { itr.remover o sistema ();}.as.println ("ArrayList After:" + numbers); OutputArrayList Before: ArrayList After: 

That’s all on this post about How to remove object from ArrayList in Java. Aprendemos duas maneiras de remover um objeto ou elemento do ArrayList. A propósito, você deve sempre usar remove (index) para excluir objeto, se você não estiver iterando, caso contrário Sempre usar o método iterator remove () para remover objeto do ArrayList. A propósito, as dicas acima trabalharão com qualquer implementação de Lista baseada em índices.
Further Learning
Java In-Depth: Become a Complete Java Engineer
Java Fundamentals: Collections
Data Structures and Algorithms: Deep Dive Using Java
Algorithms and Data Structures-Part 1 and 2
Data Structures in Java 9 by Heinz Kabutz