Das Durchlaufen einer Sammlung, die Vermeidung ConcurrentModificationException beim entfernen von Objekten in einer Schleife

Iterator.remove() ist sicher, Sie können es verwenden, wie diese:

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

Beachten Sie, dass Iterator.remove() ist der einzige sichere Weg zum ändern einer collection während iteration; das Verhalten ist nicht spezifiziert, wenn die zugrunde liegende Sammlung ist geändert in sonstiger Weise während der iteration im Gange.

Quelle: docs.oracle - > Die Collection-Schnittstelle

Ebenso, wenn Sie eine ListIterator und möchten hinzufügen Elemente, die Sie verwenden können,ListIterator#add, aus dem gleichen Grund können Sie Iterator#remove — es ist entworfen, um es zu ermöglichen.

In Ihrem Fall, dass Sie versucht zu entfernen aus einer Liste, aber die gleiche Einschränkung gilt, wenn Sie versuchen zu put in eine Map während der Iteration Ihre Inhalte.

InformationsquelleAutor Bill K

Mit Java 8 können Sie die neuen removeIf Methode. Angewendet auf dein Beispiel:

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

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

InformationsquelleAutor assylias

Können Sie entweder den iterator direkt wie du Sie erwähnt hast, sonst halten Sie eine zweite Sammlung, und fügen Sie jedes Element, das Sie entfernen möchten, um die neue Kollektion, dann removeAll am Ende. Dies ermöglicht Ihnen, halten mit der Typ-Sicherheit der for-each-Schleife, auf Kosten der erhöhten Speicher und cpu-Zeit (sollte nicht ein großes problem sein, es sei denn, Sie haben wirklich, wirklich großen Listen oder einem wirklich alten computer)

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

InformationsquelleAutor RodeoClown

Gleiche Antwort wie Claudius mit einer for-Schleife:

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

InformationsquelleAutor Antzi

Machen Sie eine Kopie der vorhandenen Liste und Durchlaufen neue Kopie.

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

InformationsquelleAutor Priyank Doshi

Menschen sind, die Durchsetzung nicht entfernen aus einer Collection iteriert durch eine foreach-Schleife. Ich wollte nur darauf hinweisen, dass technisch falsch und genau beschreiben (ich weiß, die OP-Frage ist so weit Fortgeschritten, wie man dieses wissen) der code hinter dieser Annahme:

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

Es ist nicht, dass Sie nicht entfernen können von der iterierten Colletion eher, dass man nicht dann weiterhin iteration, wenn Sie tun. Daher der break im code oben.

Entschuldigung, wenn diese Antwort ist eine etwas spezialisierte use-case und mehr geeignet, um die original - thread ich hier angekommen aus, dass man als Duplikat gekennzeichnet (trotz diesem thread erscheinen differenziertere) dieser und gesperrt.

InformationsquelleAutor John

Ich habe einen Vorschlag für das problem oben. Keine Notwendigkeit von sekundären Liste oder eine zusätzliche Zeit. Finden Sie ein Beispiel, das würde die gleichen Sachen, aber in einer anderen Weise.

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

Dies würde vermeiden, dass die Parallelität Ausnahme.

InformationsquelleAutor Nandhan Thiravia

Die Beste Möglichkeit(Empfohlen), Verwendung von java.util.Concurrent-Paket . Durch
mit diesem Paket können Sie ganz einfach vermeiden diese Ausnahme . finden
Geänderten Code

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

InformationsquelleAutor jagdish khetre

Im Falle ArrayList:remove(int index)- if(index letztes element position) es vermeidet, ohne System.arraycopy() und nimmt sich nicht die Zeit dafür.

arraycopy Zeit erhöht wenn(index sinkt), durch die Art und Weise Elemente der Liste auch abnimmt!

die besten effektiven entfernen, Weg ist - das entfernen Ihrer Elemente in absteigender Reihenfolge:
while(list.size()>0)list.remove(list.size()-1);//O(1)
while(list.size()>0)list.remove(0);//O(factorial(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

• für index-Schleife: 1090 MS
• für desc-index: 519 MS---das beste
• für iterator: 1043 MS

InformationsquelleAutor Nurlan

Beispiel für thread-sichere collection Modifikation:

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

InformationsquelleAutor Yazon2006

Ich weiß, diese Frage nimmt auch eine Collection, und nicht konkret alle List. Aber für diejenigen, die Lesen diese Frage, die in der Tat die Arbeit mit einem List Referenz, können Sie vermeiden ConcurrentModificationException mit einem while-loop (beim ändern) statt, wenn Sie vermeiden möchten Iterator (entweder, wenn Sie wollen, vermeiden es im Allgemeinen, oder vermeiden Sie es insbesondere, zu erreichen, eine Schleife, um verschiedene von start-zu-Ende-halt an jedes element [was ich glaube ist das einzige, um Iterator selbst tun können]):

*Update: Siehe Kommentare unten, die Klärung der Analog ist auch erreichbar mit dem traditionellen-for-Schleife.

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

Keine ConcurrentModificationException aus, dass code.

Hier sehen wir den looping nicht am Anfang beginnen, und nicht aufhören, an jeder element ist (ich glaube Iterator selbst nicht tun können).

FWIW wir sehen auch get aufgerufen list, die nicht getan werden konnte, wenn seine Referenz war nur Collection (statt der spezifischen List-Typ Collection) - List Schnittstelle umfasst get, aber Collection - Schnittstelle nicht. Wenn nicht für diese Differenz, dann die list Referenz könnte stattdessen ein Collection [und daher technisch ist diese Antwort wäre dann eine direkte Antwort, stattdessen eine tangentiale Antwort].

FWIWW gleiche code funktioniert immer noch nach modifiziert, um start zu Beginn an der Haltestelle bei der jedes element (genau wie Iterator Reihenfolge):

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

InformationsquelleAutor cellepo

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

Lambda Ausdrücke und Collection-Methoden im Jdk 8 kommt im Handlichen und fügt einige syntaktische Zucker ?.

Die Methode removeIf Schleifen durch die Sammlung und Filter mit Prädikat. Ein Prädikat ist eine Funktion von einem argument, das einen booleschen Wert zurückzugeben...
Wie boolean _bool = (str) -> str.equals("text");

InformationsquelleAutor Barnabas Ukwuani