Como evitar java.util.ConcurrentModificationException ao iterar e remover elementos de um ArrayList

Eu tenho um ArrayList que eu quero iterar. Enquanto iterando sobre isso, tenho que remover elementos ao mesmo tempo. Obviamente, isso gera um java.util.ConcurrentModificationException.

Qual é a melhor prática para lidar com esse problema? Devo clonar a lista primeiro?

Eu removo os elementos não no próprio loop, mas em outra parte do código.

Meu código fica assim:

public class Test() {
    private ArrayList<A> abc = new ArrayList<A>();

    public void doStuff() {
        for (A a : abc) 
        a.doSomething();
    }

    public void removeA(A a) {
        abc.remove(a);
    }
}

a.doSomething pode ligar Test.removeA() ;

Duas opções:

• Crie uma lista de valores que você deseja remover, adicione a essa lista dentro do loop e chame originalList.removeAll(valuesToRemove)no final
• Use o remove()método no próprio iterador. Observe que isso significa que você não pode usar o loop for aprimorado.

Como um exemplo da segunda opção, removendo quaisquer cadeias com um comprimento maior que 5 de uma lista:

List<String> list = new ArrayList<String>();
...
for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
    String value = iterator.next();
    if (value.length() > 5) {
        iterator.remove();
    }
}

Dos JavaDocs do ArrayList

Os iteradores retornados pelos métodos iterator e listIterator dessa classe são rápidos: se a lista for modificada estruturalmente a qualquer momento após a criação do iterador, de qualquer forma, exceto pelos métodos de remoção ou adição do próprio iterador, o iterador lançará uma ConcurrentModificationException.

Você está tentando remover o valor da lista no avançado "for loop", o que não é possível, mesmo se você aplicar algum truque (o que você fez no seu código). A melhor maneira é codificar o nível do iterador, conforme recomendado aqui.

Eu me pergunto como as pessoas não sugeriram a abordagem tradicional para loop.

for( int i = 0; i < lStringList.size(); i++ )
{
    String lValue = lStringList.get( i );
    if(lValue.equals("_Not_Required"))
    {
         lStringList.remove(lValue);
         i--; 
    }  
}

Isso também funciona.

Você realmente deve apenas repetir a matriz da maneira tradicional

Sempre que você remover um elemento da lista, os elementos posteriores serão enviados adiante. Contanto que você não altere outros elementos além do iterativo, o código a seguir deve funcionar.

public class Test(){
    private ArrayList<A> abc = new ArrayList<A>();

    public void doStuff(){
        for(int i = (abc.size() - 1); i >= 0; i--) 
            abc.get(i).doSomething();
    }

    public void removeA(A a){
        abc.remove(a);
    }
}

No Java 8, você pode usar a Interface de coleção e fazer isso chamando o método removeIf:

yourList.removeIf((A a) -> a.value == 2);

Mais informações podem ser encontradas aqui

Faça o loop da maneira normal, o java.util.ConcurrentModificationException é um erro relacionado aos elementos que são acessados.

Então tente:

for(int i = 0; i < list.size(); i++){
    lista.get(i).action();
}

Ao iterar a lista, se você deseja remover o elemento, é possível. Vamos ver abaixo meus exemplos,

ArrayList<String>  names = new ArrayList<String>();
        names.add("abc");
        names.add("def");
        names.add("ghi");
        names.add("xyz");

Eu tenho os nomes acima da lista Array. E eu quero remover o nome "def" da lista acima,

for(String name : names){
    if(name.equals("def")){
        names.remove("def");
    }
}

O código acima lança a exceção ConcurrentModificationException porque você está modificando a lista durante a iteração.

Portanto, para remover o nome "def" do Arraylist dessa maneira,

Iterator<String> itr = names.iterator();            
while(itr.hasNext()){
    String name = itr.next();
    if(name.equals("def")){
        itr.remove();
    }
}

O código acima, através do iterador, podemos remover o nome "def" da Arraylist e tentar imprimir a matriz; você verá a saída abaixo.

Saída: [abc, ghi, xyz]

Uma opção é modificar o removeAmétodo para isso -

public void removeA(A a,Iterator<A> iterator) {
     iterator.remove(a);
     }

Mas isso significa que você doSomething()deve ser capaz de passar iteratoro removemétodo. Não é uma boa ideia.

Você pode fazer isso na abordagem em duas etapas: No primeiro loop, quando você iterar sobre a lista, em vez de remover os elementos selecionados, marque- os como a serem excluídos . Para isso, você pode simplesmente copiar esses elementos (cópia superficial) em outro List.

Depois que sua iteração estiver concluída, basta fazer a removeAllpartir da primeira lista todos os elementos na segunda lista.

Aqui está um exemplo em que eu uso uma lista diferente para adicionar os objetos a serem removidos e depois uso stream.foreach para remover elementos da lista original:

private ObservableList<CustomerTableEntry> customersTableViewItems = FXCollections.observableArrayList();
...
private void removeOutdatedRowsElementsFromCustomerView()
{
    ObjectProperty<TimeStamp> currentTimestamp = new SimpleObjectProperty<>(TimeStamp.getCurrentTime());
    long diff;
    long diffSeconds;
    List<Object> objectsToRemove = new ArrayList<>();
    for(CustomerTableEntry item: customersTableViewItems) {
        diff = currentTimestamp.getValue().getTime() - item.timestamp.getValue().getTime();
        diffSeconds = diff / 1000 % 60;
        if(diffSeconds > 10) {
            // Element has been idle for too long, meaning no communication, hence remove it
            System.out.printf("- Idle element [%s] - will be removed\n", item.getUserName());
            objectsToRemove.add(item);
        }
    }
    objectsToRemove.stream().forEach(o -> customersTableViewItems.remove(o));
}

Em vez de usar Para cada loop, use normal para loop. por exemplo, o código abaixo remove todo o elemento na lista de matrizes sem fornecer java.util.ConcurrentModificationException. Você pode modificar a condição no loop de acordo com seu caso de uso.

   for(int i=0;i<abc.size();i++)  {

          e.remove(i);
        }

Faça algo simples como este:

for (Object object: (ArrayList<String>) list.clone()) {
    list.remove(object);
}

Uma solução Java 8 alternativa usando stream:

        theList = theList.stream()
            .filter(element -> !shouldBeRemoved(element))
            .collect(Collectors.toList());

No Java 7, você pode usar o Guava:

        theList = FluentIterable.from(theList)
            .filter(new Predicate<String>() {
                @Override
                public boolean apply(String element) {
                    return !shouldBeRemoved(element);
                }
            })
            .toImmutableList();

Observe que o exemplo do Guava resulta em uma lista imutável que pode ou não ser o que você deseja.

Você também pode usar CopyOnWriteArrayList em vez de um ArrayList. Essa é a mais recente abordagem recomendada do JDK 1.5 em diante.

No meu caso, a resposta aceita não está funcionando, ela interrompe a exceção, mas causa alguma inconsistência na minha lista. A solução a seguir está funcionando perfeitamente para mim.

List<String> list = new ArrayList<>();
List<String> itemsToRemove = new ArrayList<>();

for (String value: list) {
   if (value.length() > 5) { // your condition
       itemsToRemove.add(value);
   }
}
list.removeAll(itemsToRemove);

Neste código, adicionei os itens a serem removidos em outra lista e, em seguida, usei o list.removeAllmétodo para remover todos os itens necessários.

"Devo clonar a lista primeiro?"

Essa será a solução mais fácil, remova-a do clone e copie-o novamente após a remoção.

Um exemplo do meu jogo rummikub:

SuppressWarnings("unchecked")
public void removeStones() {
  ArrayList<Stone> clone = (ArrayList<Stone>) stones.clone();
  // remove the stones moved to the table
  for (Stone stone : stones) {
      if (stone.isOnTable()) {
         clone.remove(stone);
      }
  }
  stones = (ArrayList<Stone>) clone.clone();
  sortStones();
}

Se seu objetivo é remover todos os elementos da lista, você pode iterar sobre cada item e chamar:

list.clear()

Chego tarde, sei, mas respondo a isso porque acho que essa solução é simples e elegante:

List<String> listFixed = new ArrayList<String>();
List<String> dynamicList = new ArrayList<String>();

public void fillingList() {
    listFixed.add("Andrea");
    listFixed.add("Susana");
    listFixed.add("Oscar");
    listFixed.add("Valeria");
    listFixed.add("Kathy");
    listFixed.add("Laura");
    listFixed.add("Ana");
    listFixed.add("Becker");
    listFixed.add("Abraham");
    dynamicList.addAll(listFixed);
}

public void updatingListFixed() {
    for (String newList : dynamicList) {
        if (!listFixed.contains(newList)) {
            listFixed.add(newList);
        }
    }

    //this is for add elements if you want eraser also 

    String removeRegister="";
    for (String fixedList : listFixed) {
        if (!dynamicList.contains(fixedList)) {
            removeResgister = fixedList;
        }
    }
    fixedList.remove(removeRegister);
}

Tudo isso é para atualizar de uma lista para outra e você pode fazer tudo de apenas uma lista. No método de atualização, você verifica a lista e pode apagar ou adicionar elementos entre a lista. Isso significa que ambos listam sempre o mesmo tamanho

Use o iterador em vez da lista de matrizes

Faça com que um conjunto seja convertido em iterador com correspondência de tipo

E vá para o próximo elemento e remova

Iterator<Insured> itr = insuredSet.iterator();
while (itr.hasNext()) { 
    itr.next();
    itr.remove();
}

Mover para o próximo é importante aqui, pois deve levar o índice para remover o elemento.

Que tal de

import java.util.Collections;

List<A> abc = Collections.synchronizedList(new ArrayList<>());

Basta adicionar uma pausa após a instrução ArrayList.remove (A)