L'itération sur une Collection, en évitant ConcurrentModificationException lors de la suppression d'objets dans une boucle

Itérateur.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();
    }
}

Noter que Itérateur.remove() est la seule façon de modifier une collection au cours d'une itération; le comportement est indéfini si la collection sous-jacente est modifié de toute autre manière tandis que l'itération est en cours.

Source: docs.oracle > L'Interface de Collecte

Et de même, si vous avez un ListIterator et souhaitez ajouter éléments, vous pouvez utiliser ListIterator#ajouter, pour la même raison, vous pouvez utiliser Iterator#remove — il est conçu pour permettre.

Dans votre cas, vous avez essayé de supprimer à partir d'une liste, mais la même restriction s'applique si vous essayez de put dans un Map lors de l'itération de son contenu.

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

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

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

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

public static void main(String[] args)
{
    Collection<Integer> l = new ArrayList<Integer>();
    Collection<Integer> itemsToRemove = 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));
    }
    for (Integer i : l)
    {
        if (i.intValue() == 5)
            itemsToRemove.add(i);
    }

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

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

Faire une copie de la liste existante et effectuer une itération sur nouvelle copie.

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

Les gens sont revendiquant ne peut pas supprimer à partir d'une Collecte de données par une boucle foreach. Je voulais juste faire remarquer que est techniquement incorrect et décrire exactement (je sais que l'OP question est tellement avancé que pour obvier à savoir ce) 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 retirer de l'itéré Colletion plutôt que vous ne pouvez pas continuer ensuite itération une fois que vous faites. D'où la break dans le code ci-dessus.

Excuses si cette réponse est un peu le spécialiste de cas d'utilisation et plus adapté à l'original fil je suis arrivé ici, que l'un est marqué comme un doublon (en dépit de ce fil apparaissant plus nuancée), du présent et verrouillé.

J'ai une suggestion pour le problème ci-dessus. Pas besoin de liste secondaire ou le temps. Vous trouverez un exemple qui ferait la même chose mais de 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 permettrait d'éviter la Simultanéité d'Exception.

La Meilleure façon(Recommandé) est l'utilisation de java.util.Simultanées paquet . Par
l'utilisation de ce package, vous pouvez facilement éviter cette Exception . reportez-vous
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);
    }

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

arraycopy temps augmente si(index diminue), par la façon dont les éléments de la liste diminue aussi!

le meilleur efficaces supprimer façon est - retrait de 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(factorielle(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 l'indice de boucle: 1090 msec
• pour le desc indice: 519 msec---le meilleur
• pour itérateur: 1043 msec

Exemple de thread-safe modification de collection:

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 simplement une Collection, et pas plus précisément de toute List. Mais pour ceux qui lisent cette question, qui sont en effet de travailler avec un List de référence, vous pouvez éviter ConcurrentModificationException avec un while-boucle (lors de la modification de l'intérieur) à la place si vous voulez éviter de Iterator (si vous voulez l'éviter en général, ou de l'éviter spécifiquement pour réaliser une boucle de commande différent du début à la fin en s'arrêtant à chaque élément [je crois que c'est le seul ordre Iterator lui-même peut faire]):

*Mise à jour: Voir les commentaires ci-dessous qui permettent de préciser l'analogie est aussi possible avec l' traditionnel-pour-boucle.

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

Pas ConcurrentModificationException de ce code.

Il nous voyons en boucle démarre pas au début, et ne pas s'arrêter à chaque élément (qui, je crois Iterator lui-même ne peut pas le faire).

FWIW, nous voyons aussi get d'être appelé list, qui ne pouvait pas être fait si sa référence était juste Collection (à la place de celui, plus spécifique, List- type de Collection) - List interface comprend get, mais Collection interface ne fonctionne pas. Si ce n'est pour la différence, alors les list de référence pourrait être plutôt une 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 de commencer au début à s'arrêter à chaque élément (comme Iterator l'ordre):

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

Collection<Integer> l = new ArrayList<Integer>();//Do the collection thing...
l.removeIf(i -> i == 5);      //iterates through the collection and removes every occurence of 5

Les expressions Lambda et méthodes de Collecte dans le Jdk 8 est très Pratique et ajoute du sucre syntaxique .

La méthode removeIf boucles à travers la collecte et de filtres avec Prédicat. Un Prédicat est fonction d'un argument qui retournent un booléen...
Tout comme boolean _bool = (str) -> str.equals("text");