Iterasi melalui Koleksi, menghindari ConcurrentModificationException saat menghapus objek dalam satu lingkaran

Kita semua tahu Anda tidak dapat melakukan hal berikut karena ConcurrentModificationException:

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

Tapi ini tampaknya bekerja kadang-kadang, tetapi tidak selalu. Ini beberapa kode spesifik:

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

Ini, tentu saja, menghasilkan:

Exception in thread "main" java.util.ConcurrentModificationException

Meskipun beberapa utas tidak melakukannya. Bagaimanapun.

Apa solusi terbaik untuk masalah ini? Bagaimana saya bisa menghapus item dari koleksi dalam satu lingkaran tanpa membuang pengecualian ini?

Saya juga menggunakan arbitrer di Collectionsini, tidak harus ArrayList, jadi Anda tidak bisa mengandalkan get.

Iterator.remove() aman, Anda bisa menggunakannya seperti ini:

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

Perhatikan bahwa Iterator.remove()satu-satunya cara aman untuk mengubah koleksi selama iterasi; perilaku tidak ditentukan jika koleksi yang mendasarinya dimodifikasi dengan cara lain saat iterasi sedang berlangsung.

Sumber: docs.oracle> The Collection Interface

Dan demikian pula, jika Anda memiliki ListIteratordan ingin menambahkan item, Anda dapat menggunakan ListIterator#add, untuk alasan yang sama Anda dapat menggunakan Iterator#remove - itu dirancang untuk memungkinkannya.

Dalam kasus Anda Anda mencoba untuk menghapus dari daftar, tapi pembatasan yang sama berlaku jika mencoba untuk putmenjadi Mapsementara iterasi isinya.

Ini bekerja:

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

Saya berasumsi bahwa karena foreach loop adalah gula sintaksis untuk iterasi, menggunakan iterator tidak akan membantu ... tetapi memberi Anda .remove()fungsi ini .

Dengan Java 8 Anda dapat menggunakan metode baruremoveIf . Diterapkan pada contoh Anda:

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

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

Karena pertanyaan telah dijawab yaitu cara terbaik adalah menggunakan metode hapus dari objek iterator, saya akan pergi ke spesifik tempat di mana kesalahan "java.util.ConcurrentModificationException"dilemparkan.

Setiap kelas koleksi memiliki kelas pribadi yang mengimplementasikan antarmuka Iterator dan menyediakan metode seperti next(), remove()dan hasNext().

Kode untuk selanjutnya terlihat seperti ini ...

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

Di sini metode checkForComodificationdiimplementasikan sebagai

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

Jadi, seperti yang Anda lihat, jika Anda secara eksplisit mencoba menghapus elemen dari koleksi. Ini menghasilkan modCountperbedaan dari expectedModCount, menghasilkan pengecualian ConcurrentModificationException.

Anda dapat menggunakan iterator secara langsung seperti yang Anda sebutkan, atau menyimpan koleksi kedua dan menambahkan setiap item yang ingin Anda hapus ke koleksi baru, lalu hapus semua di bagian akhir. Hal ini memungkinkan Anda untuk tetap menggunakan jenis-keamanan loop untuk-masing-masing dengan biaya peningkatan penggunaan memori dan waktu cpu (seharusnya tidak menjadi masalah besar kecuali Anda memiliki daftar yang benar-benar besar atau komputer yang benar-benar tua)

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

Dalam kasus seperti itu, trik umum adalah (dulu?) Untuk mundur:

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

Yang mengatakan, saya sangat senang bahwa Anda memiliki cara yang lebih baik di Java 8, misalnya removeIfatau filterdi stream.

Jawaban yang sama dengan Claudius dengan for for:

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

Dengan Eclipse Collections , metode yang removeIfdidefinisikan pada MutableCollection akan berfungsi:

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

Dengan sintaks Java 8 Lambda ini dapat ditulis sebagai berikut:

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

Panggilan ke Predicates.cast()diperlukan di sini karena removeIfmetode default telah ditambahkan pada java.util.Collectionantarmuka di Java 8.

Catatan: Saya pengendara untuk Eclipse Collections .

Buat salinan dari daftar yang ada dan ulangi salinan baru.

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

Orang-orang menyatakan seseorang tidak dapat menghapus dari Koleksi yang diulangi oleh loop foreach. Saya hanya ingin menunjukkan bahwa secara teknis tidak benar dan menjelaskan dengan tepat (saya tahu pertanyaan OP sangat canggih untuk menghindari mengetahui ini) kode di belakang asumsi itu:

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

Ini bukan berarti Anda tidak dapat menghapus dari iterasi Colletiondaripada Anda tidak dapat melanjutkan iterasi setelah melakukannya. Karenanya breakdalam kode di atas.

Mohon maaf jika jawaban ini agak khusus untuk kasus penggunaan dan lebih cocok untuk utas asli tempat saya tiba di sini, yang ditandai sebagai duplikat (meskipun utas ini tampak lebih bernuansa) dan dikunci.

Dengan loop tradisional

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 ListIteratormemungkinkan Anda untuk menambah atau menghapus item dalam daftar. Misalkan Anda memiliki daftar Carobjek:

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

Saya punya saran untuk masalah di atas. Tidak perlu daftar sekunder atau waktu tambahan. Silakan temukan contoh yang akan melakukan hal yang sama tetapi dengan cara yang berbeda.

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

Ini akan menghindari Pengecualian Konkurensi.

ConcurrentHashMap atau ConcurrentLinkedQueue atau ConcurrentSkipListMap dapat menjadi pilihan lain, karena mereka tidak akan pernah membuang ConcurrentModificationException, bahkan jika Anda menghapus atau menambahkan item.

Saya tahu pertanyaan ini terlalu tua untuk tentang Java 8, tetapi bagi mereka yang menggunakan Java 8 Anda dapat dengan mudah menggunakan 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);

Cara lain adalah dengan membuat salinan arrayList Anda:

List<Object> l = ...

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

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

Cara terbaik (Disarankan) adalah menggunakan paket java.util.Concurrent. Dengan menggunakan paket ini Anda dapat dengan mudah menghindari Pengecualian ini. lihat Kode yang Dimodifikasi

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

Dalam hal ArrayList: hapus (indeks int) - jika (indeks adalah posisi elemen terakhir) ia menghindari tanpa System.arraycopy()dan tidak membutuhkan waktu untuk ini.

waktu arraycopy meningkat jika (indeks berkurang), dengan cara elemen-elemen daftar juga berkurang!

cara menghapus efektif terbaik adalah- menghapus elemen-elemennya dalam urutan menurun: while(list.size()>0)list.remove(list.size()-1);// take O (1) while(list.size()>0)list.remove(0);// take 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

• untuk loop indeks: 1090 msec
• untuk indeks desc: 519 msec --- yang terbaik
• untuk iterator: 1043 msec

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

Tangkapannya adalah setelah menghapus elemen dari daftar jika Anda melewatkan panggilan iterator.next internal (). masih bekerja! Meskipun saya tidak mengusulkan untuk menulis kode seperti ini, ada baiknya memahami konsep di baliknya :-)

Bersulang!

Contoh modifikasi pengumpulan aman thread:

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

Saya tahu pertanyaan ini mengasumsikan hanya Collection, dan tidak lebih spesifik List. Tetapi bagi mereka yang membaca pertanyaan ini yang memang bekerja dengan Listreferensi, Anda dapat menghindari ConcurrentModificationExceptiondengan while-loop (sambil memodifikasi di dalamnya) sebagai gantinya jika Anda ingin menghindariIterator (baik jika Anda ingin menghindarinya secara umum, atau menghindarinya secara khusus untuk mencapai urutan pengulangan berbeda dari berhenti dari awal hingga akhir di setiap elemen [yang saya percaya adalah satu-satunya urutan yang Iteratordapat dilakukan sendiri)):

* Pembaruan: Lihat komentar di bawah ini yang memperjelas analog juga dapat dicapai dengan loop tradisional .

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

Tidak ada ConcurrentModificationException dari kode itu.

Di sana kita melihat perulangan tidak dimulai di awal, dan tidak berhenti di setiap elemen (yang saya percaya Iteratortidak bisa lakukan).

FWIW kita juga melihat getdipanggil list, yang tidak dapat dilakukan jika referensi itu hanya Collection(bukan Listtipe -lebih spesifik dari Collection) - Listantarmuka termasuk get, tetapi Collectionantarmuka tidak. Jika bukan karena perbedaan itu, maka listrujukannya bisa menjadi Collection[dan karena itu secara teknis Jawaban ini kemudian akan menjadi Jawaban langsung, bukan Jawaban tangensial].

FWIWW kode yang sama masih berfungsi setelah dimodifikasi untuk mulai dari awal di berhenti di setiap elemen (seperti Iteratorpesanan):

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

Salah satu solusinya adalah dengan memutar daftar dan menghapus elemen pertama untuk menghindari ConcurrentModificationException atau 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);

Coba yang ini (hapus semua elemen dalam daftar yang sama i):

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

Anda juga dapat menggunakan Rekursi

Rekursi dalam java adalah suatu proses di mana suatu metode menyebut dirinya secara terus menerus. Metode dalam java yang menyebut dirinya disebut metode rekursif.

ini mungkin bukan cara terbaik, tetapi untuk sebagian besar kasus kecil ini harus dapat diterima:

"buat array kosong kedua dan tambahkan hanya yang ingin Anda simpan"

_{Saya tidak ingat di mana saya membaca ini dari ... untuk keadilan saya akan membuat wiki ini dengan harapan seseorang menemukannya atau hanya untuk tidak mendapatkan perwakilan saya tidak pantas.}