Iterowanie przez kolekcję, unikanie ConcurrentModificationException podczas usuwania obiektów w pętli

Wszyscy wiemy, że nie możesz wykonać następujących czynności z powodu ConcurrentModificationException:

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

Ale to najwyraźniej działa czasami, ale nie zawsze. Oto konkretny kod:

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

To oczywiście skutkuje:

Exception in thread "main" java.util.ConcurrentModificationException

Nawet jeśli wiele wątków tego nie robi. Tak czy siak.

Jakie jest najlepsze rozwiązanie tego problemu? Jak mogę usunąć element z kolekcji w pętli bez zgłaszania tego wyjątku?

Używam tu również arbitralnego Collection, niekoniecznie ArrayList, więc nie możesz na nim polegać get.

Iterator.remove() jest bezpieczny, możesz go użyć w następujący sposób:

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

Pamiętaj, że Iterator.remove()jest to jedyny bezpieczny sposób modyfikowania kolekcji podczas iteracji; zachowanie nie jest określone, jeśli podstawowa kolekcja zostanie zmodyfikowana w jakikolwiek inny sposób podczas iteracji.

Źródło: docs.oracle> Interfejs kolekcji

I podobnie, jeśli masz ListIteratori chcesz dodać elementy, możesz użyć ListIterator#add, z tego samego powodu, którego możesz użyć Iterator#remove - jest tak zaprojektowane, aby na to pozwolić.

W twoim przypadku próbowałeś usunąć z listy, ale to samo ograniczenie obowiązuje, jeśli próbujesz przez putjakiś Mapczas iterować jego zawartość.

To działa:

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

Założyłem, że ponieważ pętla foreach to cukier syntaktyczny do iteracji, użycie iteratora nie pomogłoby ... ale daje tę .remove()funkcjonalność.

W Javie 8 możesz użyć nowej removeIfmetody . Dotyczy twojego przykładu:

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

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

Ponieważ na pytanie już udzielono odpowiedzi, tj. Najlepszym sposobem jest użycie metody remove obiektu iteratora, przejdę do szczegółów miejsca, w którym zgłaszany "java.util.ConcurrentModificationException"jest błąd .

Każda klasa posiada prywatny zbiór klasę, która implementuje interfejs Iterator i dostarcza metod, takich jak next(), remove()i hasNext().

Kod następnego wygląda mniej więcej tak ...

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

Tutaj metoda checkForComodificationjest implementowana jako

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

Jak widać, jeśli wyraźnie spróbujesz usunąć element z kolekcji. Powoduje to, modCountże różni się od expectedModCount, co powoduje wyjątek ConcurrentModificationException.

Możesz albo użyć iteratora bezpośrednio jak wspomniano, albo zachować drugą kolekcję i dodać każdy element, który chcesz usunąć, do nowej kolekcji, a następnie usunąć wszystkie na końcu. Dzięki temu możesz nadal korzystać z bezpieczeństwa typu dla każdej pętli kosztem zwiększonego zużycia pamięci i czasu procesora (nie powinno to stanowić dużego problemu, chyba że masz naprawdę duże listy lub naprawdę stary komputer)

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

W takich przypadkach powszechną sztuczką jest (było?) Cofanie się:

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

To powiedziawszy, jestem bardziej niż szczęśliwy, że masz lepsze sposoby w Javie 8, np. removeIfLub filterw strumieniach.

Taka sama odpowiedź jak Klaudiusz z pętlą for:

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

W przypadku kolekcji Eclipse metoda removeIfzdefiniowana w MutableCollection będzie działać:

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

W składni Lambda Java 8 można to zapisać w następujący sposób:

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

Wywołanie to Predicates.cast()jest tutaj konieczne, ponieważ removeIfw java.util.Collectioninterfejsie Java 8 została dodana domyślna metoda .

Uwaga: jestem osobą odpowiedzialną za kolekcje Eclipse .

Utwórz kopię istniejącej listy i powtórz nową kopię.

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

Ludzie twierdzą, że nie można usunąć z kolekcji, która jest iterowana przez pętlę foreach. Chciałem tylko wskazać, że jest to technicznie niepoprawne i dokładnie opisać (wiem, że pytanie OP jest tak zaawansowane, że można uniknąć tego), kod stojący za tym założeniem:

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

Nie chodzi o to, że nie można usunąć iteracji, Colletiona raczej o to, że nie można kontynuować iteracji. Stąd breakw powyższym kodzie.

Przepraszam, jeśli ta odpowiedź jest nieco specjalistycznym przypadkiem użycia i bardziej pasuje do oryginalnego wątku, z którego tu przybyłem, ten jest oznaczony jako duplikat (pomimo tego, że ten wątek wydaje się bardziej niuansowy) tego i zablokowany.

Z tradycyjną pętlą for

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 ListIteratorpozwala dodawać lub usuwać elementy z listy. Załóżmy, że masz listę Carobiektów:

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

Mam sugestię dotyczącą powyższego problemu. Nie potrzeba dodatkowej listy ani dodatkowego czasu. Znajdź przykład, który zrobiłby to samo, ale w inny sposób.

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

Pozwoliłoby to uniknąć wyjątku dotyczącego współbieżności.

ConcurrentHashMap lub ConcurrentLinkedQueue lub ConcurrentSkipListMap może być inną opcją, ponieważ nigdy nie zgłoszą żadnego wyjątku ConcurrentModificationExap, nawet jeśli usuniesz lub dodasz element.

Wiem, że to pytanie jest zbyt stare, aby dotyczyć Javy 8, ale dla tych, którzy używają Javy 8, możesz łatwo użyć 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);

Innym sposobem jest utworzenie kopii tablicy arrayList:

List<Object> l = ...

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

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

Najlepszym (zalecanym) sposobem jest użycie pakietu java.util.Concurrent. Korzystając z tego pakietu, możesz łatwo uniknąć tego wyjątku. odnoszą się do Zmodyfikowanego Kodu

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

W przypadku ArrayList: remove (int index) - jeśli (indeks jest pozycją ostatniego elementu) unika się go bez System.arraycopy()i nie zajmuje to czasu.

czas arraycopy wydłuża się, gdy (indeks maleje), przy okazji maleje także elementy listy!

najlepszym skutecznym sposobem usuwania jest usuwanie jej elementów w kolejności malejącej: while(list.size()>0)list.remove(list.size()-1);// przyjmuje O (1) while(list.size()>0)list.remove(0);// przyjmuje O (silnia (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

• dla pętli indeksu: 1090 ms
• dla indeksu desc: 519 ms --- najlepszy
• dla iteratora: 1043 ms

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

Złap to po usunięciu elementu z listy, jeśli pominiesz wewnętrzne wywołanie iterator.next (). wciąż działa! Chociaż nie proponuję pisać takiego kodu, pomaga zrozumieć koncepcję :-)

Twoje zdrowie!

Przykład modyfikacji bezpiecznego gromadzenia wątków:

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

Wiem, że to pytanie zakłada tylko Collection, a dokładniej żadne List. Ale dla tych, którzy czytają to pytanie, którzy faktycznie pracują z Listreferencją, możesz uniknąć ConcurrentModificationExceptionza pomocą whilepętli (podczas modyfikowania w niej), jeśli chcesz uniknąćIterator (albo jeśli chcesz uniknąć w ogóle, albo unikaj go konkretnie, aby osiągnąć kolejność zapętlania różni się od zatrzymania od początku do końca przy każdym elemencie [co, jak sądzę, jest jedynym, który Iteratorsam może wykonać]):

* Aktualizacja: patrz komentarze poniżej wyjaśniające, że analogia jest również możliwa do osiągnięcia dzięki tradycyjnej pętli-for-loop.

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

Brak ConcurrentModificationException od tego kodu.

Widzimy tam, że zapętlenie nie zaczyna się od początku i nie zatrzymuje się na każdym elemencie (w co wierzę)Iterator nie jest w stanie zrobić).

FWIW również widzimy, getże jest wywoływany list, czego nie można byłoby zrobić, gdyby jego odwołanie było po prostu Collection(zamiast bardziej specyficznego Listtypu Collection) - Listinterfejs zawiera get, ale Collectioninterfejs nie. Gdyby nie ta różnica, wówczas listodniesieniem może być Collection[i dlatego technicznie ta odpowiedź byłaby wówczas odpowiedzią bezpośrednią, zamiast odpowiedzi stycznej].

FWIWW ten sam kod nadal działa po zmodyfikowaniu, aby zaczynał od początku na stopie przy każdym elemencie (podobnie jak Iteratorkolejność):

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

Jednym z rozwiązań mogłoby być obrócenie listy i usunięcie pierwszego elementu, aby uniknąć ConcurrentModificationException lub 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);

Spróbuj tego (usuwa wszystkie elementy z listy, które są równe i):

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

może to nie być najlepszy sposób, ale w większości małych przypadków powinno to być dopuszczalne:

„utwórz drugą pustą tablicę i dodaj tylko te, które chcesz zachować”

_{Nie pamiętam, skąd to przeczytałem ... dla słuszności zrobię tę wiki w nadziei, że ktoś ją znajdzie lub po prostu nie zarobię przedstawiciela, na który nie zasługuję.}