Comment éviter java.util.ConcurrentModificationException lors de l'itération et de la suppression d'éléments d'une ArrayList

J'ai une ArrayList sur laquelle je veux répéter. Tout en itérant dessus, je dois supprimer des éléments en même temps. De toute évidence, cela jette un java.util.ConcurrentModificationException.

Quelle est la meilleure pratique pour gérer ce problème? Dois-je d'abord cloner la liste?

Je supprime les éléments non pas dans la boucle elle-même mais dans une autre partie du code.

Mon code ressemble à ceci:

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.doSomethingpourrait appeler Test.removeA();

Deux options:

• Créez une liste de valeurs que vous souhaitez supprimer, en ajoutant à cette liste dans la boucle, puis appelez originalList.removeAll(valuesToRemove)à la fin
• Utilisez la remove()méthode sur l'itérateur lui-même. Notez que cela signifie que vous ne pouvez pas utiliser la boucle for améliorée.

Comme exemple de la deuxième option, supprimer toutes les chaînes d'une longueur supérieure à 5 d'une liste:

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

À partir des JavaDocs de la ArrayList

Les itérateurs renvoyés par les méthodes iterator et listIterator de cette classe sont résistants aux défaillances: si la liste est structurellement modifiée à tout moment après la création de l'itérateur, de quelque manière que ce soit, sauf par le biais des méthodes remove ou add de l'itérateur, l'itérateur lèvera une exception ConcurrentModificationException.

Vous essayez de supprimer la valeur de la liste dans la boucle avancée "for", ce qui n'est pas possible, même si vous appliquez une astuce (ce que vous avez fait dans votre code). Le meilleur moyen est de coder le niveau de l'itérateur comme indiqué ici.

Je me demande comment les gens n'ont pas suggéré l'approche traditionnelle de la boucle.

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

Cela fonctionne aussi.

Vous devez vraiment simplement réitérer le tableau de la manière traditionnelle

Chaque fois que vous supprimez un élément de la liste, les éléments suivants seront repoussés. Tant que vous ne modifiez pas d'autres éléments que l'itération, le code suivant devrait fonctionner.

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);
    }
}

Dans Java 8, vous pouvez utiliser l'interface de collecte et le faire en appelant la méthode removeIf:

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

Plus d'informations peuvent être trouvées ici

Faites la boucle normalement, java.util.ConcurrentModificationExceptionc'est une erreur liée aux éléments auxquels vous accédez.

Alors essayez:

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

Lors de l'itération de la liste, si vous souhaitez supprimer l'élément est possible. Voyons ci-dessous mes exemples,

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

J'ai les noms ci-dessus de la liste des tableaux. Et je veux supprimer le nom "def" de la liste ci-dessus,

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

Le code ci-dessus lève l' exception ConcurrentModificationException car vous modifiez la liste lors de l'itération.

Donc, pour supprimer le nom "def" d'Arraylist en procédant de cette façon,

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

Le code ci-dessus, via l'itérateur, nous pouvons supprimer le nom "def" de la liste Arraylist et essayer d'imprimer le tableau, vous verrez la sortie ci-dessous.

Sortie: [abc, ghi, xyz]

Une option consiste à modifier la removeAméthode en ceci -

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

Mais cela signifierait que vous doSomething()devriez pouvoir passer iteratorà la removeméthode. Ce n'est pas une bonne idée.

Pouvez-vous le faire en deux étapes: dans la première boucle lorsque vous parcourez la liste, au lieu de supprimer les éléments sélectionnés, marquez- les comme devant être supprimés . Pour cela, vous pouvez simplement copier ces éléments (copie superficielle) dans un autre List.

Ensuite, une fois votre itération terminée, faites simplement a removeAllpartir de la première liste tous les éléments de la seconde liste.

Voici un exemple où j'utilise une liste différente pour ajouter les objets à supprimer, puis j'utilise stream.foreach pour supprimer des éléments de la liste d'origine:

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));
}

Au lieu d'utiliser Pour chaque boucle, utilisez la boucle normale. par exemple, le code ci-dessous supprime tous les éléments de la liste de tableaux sans donner java.util.ConcurrentModificationException. Vous pouvez modifier la condition dans la boucle en fonction de votre cas d'utilisation.

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

          e.remove(i);
        }

Faites quelque chose de simple comme ceci:

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

Une solution alternative Java 8 utilisant stream:

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

Dans Java 7, vous pouvez utiliser Guava à la place:

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

Notez que l'exemple de Guava se traduit par une liste immuable qui peut ou non être ce que vous voulez.

Vous pouvez également utiliser CopyOnWriteArrayList au lieu d'une ArrayList. Il s'agit de la dernière approche recommandée à partir de JDK 1.5.

Dans mon cas, la réponse acceptée ne fonctionne pas, elle arrête l'exception mais elle provoque une incohérence dans ma liste. La solution suivante fonctionne parfaitement pour moi.

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);

Dans ce code, j'ai ajouté les éléments à supprimer, dans une autre liste, puis utilisé la list.removeAllméthode pour supprimer tous les éléments requis.

"Dois-je d'abord cloner la liste?"

Ce sera la solution la plus simple, supprimez du clone et recopiez le clone après la suppression.

Un exemple de mon jeu de 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();
}

Si votre objectif est de supprimer tous les éléments de la liste, vous pouvez parcourir chaque élément, puis appeler:

list.clear()

J'arrive en retard je sais mais je réponds à cela car je pense que cette solution est simple et élégante:

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);
}

Tout cela est pour la mise à jour d'une liste à l'autre et vous pouvez tout faire à partir d'une seule liste et dans la mise à jour de la méthode, vous vérifiez les deux listes et pouvez effacer ou ajouter des éléments entre la liste. Cela signifie que les deux affichent toujours la même taille

Utiliser Iterator au lieu de Array List

Faire convertir un ensemble en itérateur avec correspondance de type

Et passer à l'élément suivant et supprimer

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

Le passage au suivant est important ici car il devrait prendre l'index pour supprimer l'élément.

Qu'en est-il de

import java.util.Collections;

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

Ajoutez simplement une pause après votre instruction ArrayList.remove (A)