Itération à travers une collection, en évitant ConcurrentModificationException lors de la suppression d'objets dans une boucle

Nous savons tous que vous ne pouvez pas faire ce qui suit à cause de ConcurrentModificationException:

for (Object i : l) {
    if (condition(i)) {
        l.remove(i);
    }
}

Mais cela fonctionne apparemment parfois, mais pas toujours. Voici un code spécifique:

public static void main(String[] args) {
    Collection<Integer> l = new ArrayList<>();

    for (int i = 0; i < 10; ++i) {
        l.add(4);
        l.add(5);
        l.add(6);
    }

    for (int i : l) {
        if (i == 5) {
            l.remove(i);
        }
    }

    System.out.println(l);
}

Cela se traduit bien sûr par:

Exception in thread "main" java.util.ConcurrentModificationException

Même si plusieurs threads ne le font pas. En tous cas.

Quelle est la meilleure solution à ce problème? Comment puis-je supprimer un élément de la collection dans une boucle sans lever cette exception?

J'utilise également un arbitraire Collectionici, pas nécessairement un ArrayList, donc vous ne pouvez pas vous fier get.

Iterator.remove() est sûr, vous pouvez l'utiliser comme ceci:

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

// This is a clever way to create the iterator and call iterator.hasNext() like
// you would do in a while-loop. It would be the same as doing:
//     Iterator<String> iterator = list.iterator();
//     while (iterator.hasNext()) {
for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
    String string = iterator.next();
    if (string.isEmpty()) {
        // Remove the current element from the iterator and the list.
        iterator.remove();
    }
}

Notez que Iterator.remove()c'est le seul moyen sûr de modifier une collection pendant l'itération; le comportement n'est pas spécifié si la collection sous-jacente est modifiée d'une autre manière pendant l'itération.

Source: docs.oracle> L'interface de collection

Et de même, si vous en avez un ListIteratoret que vous souhaitez ajouter des éléments, vous pouvez utiliser ListIterator#add, pour la même raison que vous pouvez utiliser Iterator#remove - il est conçu pour le permettre.

Dans votre cas, vous avez tenté de supprimer une liste, mais la même restriction s'applique si vous essayez de le faire puten Mapitérant son contenu.

Cela marche:

Iterator<Integer> iter = l.iterator();
while (iter.hasNext()) {
    if (iter.next() == 5) {
        iter.remove();
    }
}

J'ai supposé que, comme une boucle foreach est un sucre syntaxique pour l'itération, l'utilisation d'un itérateur n'aiderait pas ... mais cela vous donne cette .remove()fonctionnalité.

Avec Java 8, vous pouvez utiliser la nouvelle removeIfméthode . Appliqué à votre exemple:

Collection<Integer> coll = new ArrayList<>();
//populate

coll.removeIf(i -> i == 5);

Puisque la question a déjà été répondue, c'est-à-dire que la meilleure façon est d'utiliser la méthode remove de l'objet itérateur, j'entrerais dans les détails de l'endroit où l'erreur "java.util.ConcurrentModificationException"est levée.

Chaque classe de collection a une classe privée qui implémente l'interface Iterator et fournit des méthodes comme next(), remove()et hasNext().

Le code pour next ressemble à ceci ...

public E next() {
    checkForComodification();
    try {
        E next = get(cursor);
        lastRet = cursor++;
        return next;
    } catch(IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
    }
}

Ici, la méthode checkForComodificationest implémentée comme

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

Donc, comme vous pouvez le voir, si vous essayez explicitement de supprimer un élément de la collection. Il en résulte modCountune différence avec expectedModCount, ce qui entraîne l'exception ConcurrentModificationException.

Vous pouvez soit utiliser l'itérateur directement comme vous l'avez mentionné, soit conserver une deuxième collection et ajouter chaque élément que vous souhaitez supprimer à la nouvelle collection, puis supprimer tout à la fin. Cela vous permet de continuer à utiliser la sécurité de type de la boucle for-each au prix d'une utilisation accrue de la mémoire et du temps processeur (cela ne devrait pas être un gros problème sauf si vous avez de très, très grandes listes ou un très vieil ordinateur)

public static void main(String[] args)
{
    Collection<Integer> l = new ArrayList<Integer>();
    Collection<Integer> itemsToRemove = new ArrayList<>();
    for (int i=0; i < 10; i++) {
        l.add(Integer.of(4));
        l.add(Integer.of(5));
        l.add(Integer.of(6));
    }
    for (Integer i : l)
    {
        if (i.intValue() == 5) {
            itemsToRemove.add(i);
        }
    }

    l.removeAll(itemsToRemove);
    System.out.println(l);
}

Dans de tels cas, une astuce courante est (était?) De revenir en arrière:

for(int i = l.size() - 1; i >= 0; i --) {
  if (l.get(i) == 5) {
    l.remove(i);
  }
}

Cela dit, je suis plus qu'heureux que vous ayez de meilleures méthodes en Java 8, par exemple removeIfou filtersur les flux.

Même réponse que Claudius avec une boucle for:

for (Iterator<Object> it = objects.iterator(); it.hasNext();) {
    Object object = it.next();
    if (test) {
        it.remove();
    }
}

Avec les collections Eclipse , la méthode removeIfdéfinie sur MutableCollection fonctionnera:

MutableList<Integer> list = Lists.mutable.of(1, 2, 3, 4, 5);
list.removeIf(Predicates.lessThan(3));
Assert.assertEquals(Lists.mutable.of(3, 4, 5), list);

Avec la syntaxe Java 8 Lambda, cela peut être écrit comme suit:

MutableList<Integer> list = Lists.mutable.of(1, 2, 3, 4, 5);
list.removeIf(Predicates.cast(integer -> integer < 3));
Assert.assertEquals(Lists.mutable.of(3, 4, 5), list);

L'appel à Predicates.cast()est nécessaire ici car une removeIfméthode par défaut a été ajoutée sur l' java.util.Collectioninterface dans Java 8.

Remarque: je suis un committer pour les collections Eclipse .

Faites une copie de la liste existante et parcourez la nouvelle copie.

for (String str : new ArrayList<String>(listOfStr))     
{
    listOfStr.remove(/* object reference or index */);
}

Les gens affirment que l' on ne peut pas supprimer d'une collection en cours d'itération par une boucle foreach. Je voulais juste souligner que c'est techniquement incorrect et décrire exactement (je sais que la question de l'OP est si avancée qu'elle évite de le savoir) le code derrière cette hypothèse:

for (TouchableObj obj : untouchedSet) {  // <--- This is where ConcurrentModificationException strikes
    if (obj.isTouched()) {
        untouchedSet.remove(obj);
        touchedSt.add(obj);
        break;  // this is key to avoiding returning to the foreach
    }
}

Ce n'est pas que vous ne pouvez pas supprimer de l'itéré Colletionplutôt que vous ne pouvez pas continuer l'itération une fois que vous l'avez fait. D'où le breakdans le code ci-dessus.

Toutes mes excuses si cette réponse est un cas d'utilisation quelque peu spécialisé et plus adapté au fil d' origine d'où je suis arrivé ici, celui-ci est marqué comme doublon (malgré ce fil apparaissant plus nuancé) de celui-ci et verrouillé.

Avec une boucle for traditionnelle

ArrayList<String> myArray = new ArrayList<>();

for (int i = 0; i < myArray.size(); ) {
    String text = myArray.get(i);
    if (someCondition(text))
        myArray.remove(i);
    else
        i++;   
}

A ListIteratorvous permet d'ajouter ou de supprimer des éléments dans la liste. Supposons que vous ayez une liste d' Carobjets:

List<Car> cars = ArrayList<>();
// add cars here...

for (ListIterator<Car> carIterator = cars.listIterator();  carIterator.hasNext(); )
{
   if (<some-condition>)
   { 
      carIterator().remove()
   }
   else if (<some-other-condition>)
   { 
      carIterator().add(aNewCar);
   }
}

J'ai une suggestion pour le problème ci-dessus. Pas besoin de liste secondaire ni de temps supplémentaire. Veuillez trouver un exemple qui ferait la même chose mais d'une manière différente.

//"list" is ArrayList<Object>
//"state" is some boolean variable, which when set to true, Object will be removed from the list
int index = 0;
while(index < list.size()) {
    Object r = list.get(index);
    if( state ) {
        list.remove(index);
        index = 0;
        continue;
    }
    index += 1;
}

Cela éviterait l'exception de concurrence.

ConcurrentHashMap ou ConcurrentLinkedQueue ou ConcurrentSkipListMap peuvent être une autre option, car ils ne lèveront jamais d'exception ConcurrentModificationException, même si vous supprimez ou ajoutez un élément.

Je sais que cette question est trop ancienne pour être sur Java 8, mais pour ceux qui utilisent Java 8, vous pouvez facilement utiliser removeIf ():

Collection<Integer> l = new ArrayList<Integer>();

for (int i=0; i < 10; ++i) {
    l.add(new Integer(4));
    l.add(new Integer(5));
    l.add(new Integer(6));
}

l.removeIf(i -> i.intValue() == 5);

Une autre façon consiste à créer une copie de votre arrayList:

List<Object> l = ...

List<Object> iterationList = ImmutableList.copyOf(l);

for (Object i : iterationList) {
    if (condition(i)) {
        l.remove(i);
    }
}

La meilleure façon (recommandée) est d'utiliser le package java.util.Concurrent. En utilisant ce package, vous pouvez facilement éviter cette exception. référez-vous au code modifié

public static void main(String[] args) {
    Collection<Integer> l = new CopyOnWriteArrayList<Integer>();

    for (int i=0; i < 10; ++i) {
        l.add(new Integer(4));
        l.add(new Integer(5));
        l.add(new Integer(6));
    }

    for (Integer i : l) {
        if (i.intValue() == 5) {
            l.remove(i);
        }
    }

    System.out.println(l);
}

Dans le cas où ArrayList: remove (int index) - si (index est la position du dernier élément), il évite sans System.arraycopy()et ne prend pas de temps pour cela.

le temps de tableau augmente si (l'index diminue), d'ailleurs les éléments de la liste diminuent aussi!

le meilleur moyen de suppression efficace est de supprimer ses éléments dans l'ordre décroissant: while(list.size()>0)list.remove(list.size()-1);// prend O (1) while(list.size()>0)list.remove(0);// prend O (factoriel (n))

//region prepare data
ArrayList<Integer> ints = new ArrayList<Integer>();
ArrayList<Integer> toRemove = new ArrayList<Integer>();
Random rdm = new Random();
long millis;
for (int i = 0; i < 100000; i++) {
    Integer integer = rdm.nextInt();
    ints.add(integer);
}
ArrayList<Integer> intsForIndex = new ArrayList<Integer>(ints);
ArrayList<Integer> intsDescIndex = new ArrayList<Integer>(ints);
ArrayList<Integer> intsIterator = new ArrayList<Integer>(ints);
//endregion

// region for index
millis = System.currentTimeMillis();
for (int i = 0; i < intsForIndex.size(); i++) 
   if (intsForIndex.get(i) % 2 == 0) intsForIndex.remove(i--);
System.out.println(System.currentTimeMillis() - millis);
// endregion

// region for index desc
millis = System.currentTimeMillis();
for (int i = intsDescIndex.size() - 1; i >= 0; i--) 
   if (intsDescIndex.get(i) % 2 == 0) intsDescIndex.remove(i);
System.out.println(System.currentTimeMillis() - millis);
//endregion

// region iterator
millis = System.currentTimeMillis();
for (Iterator<Integer> iterator = intsIterator.iterator(); iterator.hasNext(); )
    if (iterator.next() % 2 == 0) iterator.remove();
System.out.println(System.currentTimeMillis() - millis);
//endregion

• pour la boucle d'index: 1090 msec
• pour l'index desc: 519 msec --- le meilleur
• pour itérateur: 1043 msec

for (Integer i : l)
{
    if (i.intValue() == 5){
            itemsToRemove.add(i);
            break;
    }
}

La capture est après avoir supprimé l'élément de la liste si vous ignorez l'appel interne iterator.next (). ça fonctionne encore! Bien que je ne propose pas d'écrire du code comme celui-ci, cela aide à comprendre le concept derrière :-)

À votre santé!

Exemple de modification de collection thread-safe:

public class Example {
    private final List<String> queue = Collections.synchronizedList(new ArrayList<String>());

    public void removeFromQueue() {
        synchronized (queue) {
            Iterator<String> iterator = queue.iterator();
            String string = iterator.next();
            if (string.isEmpty()) {
                iterator.remove();
            }
        }
    }
}

Je sais que cette question suppose juste un Collection, et pas plus spécifiquement aucun List. Mais pour ceux qui lisent cette question qui travaillent en effet avec une Listréférence, vous pouvez éviter ConcurrentModificationExceptionavec un while-loop (tout en le modifiant) à la place si vous voulez éviterIterator (soit si vous voulez l'éviter en général, soit l'éviter spécifiquement pour atteindre un ordre de bouclage différent de l'arrêt de bout en bout à chaque élément [ce qui, à mon avis, est le seul ordre en Iteratorsoi]]:

* Mise à jour: Voir les commentaires ci-dessous qui précisent que l'analogue est également réalisable avec la boucle traditionnelle .

final List<Integer> list = new ArrayList<>();
for(int i = 0; i < 10; ++i){
    list.add(i);
}

int i = 1;
while(i < list.size()){
    if(list.get(i) % 2 == 0){
        list.remove(i++);

    } else {
        i += 2;
    }
}

Aucune exception ConcurrentModificationException de ce code.

Là, nous voyons que le bouclage ne démarre pas au début et ne s'arrête pas à chaque élément (ce que je crois Iteratorlui-même ne peut pas faire).

FWIW, nous voyons également getêtre appelé list, ce qui ne pourrait pas être fait si sa référence était juste Collection(au lieu du Listtype plus spécifique de Collection) - l' Listinterface inclut get, mais pas l' Collectioninterface. Si ce n'est pas pour cette différence, alors la listréférence pourrait plutôt être un Collection[et donc techniquement cette réponse serait alors une réponse directe, au lieu d'une réponse tangentielle].

FWIWW même code fonctionne toujours après modification pour commencer au début à l'arrêt à chaque élément (comme l' Iteratorordre):

final List<Integer> list = new ArrayList<>();
for(int i = 0; i < 10; ++i){
    list.add(i);
}

int i = 0;
while(i < list.size()){
    if(list.get(i) % 2 == 0){
        list.remove(i);

    } else {
        ++i;
    }
}

Une solution pourrait être de faire pivoter la liste et de supprimer le premier élément pour éviter la ConcurrentModificationException ou IndexOutOfBoundsException

int n = list.size();
for(int j=0;j<n;j++){
    //you can also put a condition before remove
    list.remove(0);
    Collections.rotate(list, 1);
}
Collections.rotate(list, -1);

Essayez celui-ci (supprime tous les éléments de la liste qui sont égaux i):

for (Object i : l) {
    if (condition(i)) {
        l = (l.stream().filter((a) -> a != i)).collect(Collectors.toList());
    }
}

vous pouvez également utiliser la récursivité

La récursivité en java est un processus dans lequel une méthode s'appelle elle-même en continu. Une méthode en Java qui s'appelle elle-même est appelée méthode récursive.

ce n'est peut-être pas le meilleur moyen, mais pour la plupart des petits cas, cela devrait être acceptable:

"créer un deuxième tableau vide et n'ajouter que ceux que vous souhaitez conserver"

_{Je ne me souviens pas d'où je lis ceci ... par justesse, je ferai ce wiki dans l'espoir que quelqu'un le trouve ou simplement pour ne pas gagner de réputation que je ne mérite pas.}