Bir ArrayList öğesinde yineleme ve öğe kaldırma sırasında java.util.ConcurrentModificationException nasıl önlenir

Tekrarlamak istediğim bir ArrayList'im var. Üzerinde yineleme yaparken aynı zamanda elemanları kaldırmak zorundayım. Açıkçası bu a atar java.util.ConcurrentModificationException.

Bu sorunu çözmek için en iyi uygulama hangisidir? Önce listeyi klonlamalı mıyım?

Döngünün kendisi değil kodun başka bir parçasındaki öğeleri kaldırırım.

Kodum şöyle görünüyor:

public class Test() {
    private ArrayList<A> abc = new ArrayList<A>();

    public void doStuff() {
        for (A a : abc) 
        a.doSomething();
    }

    public void removeA(A a) {
        abc.remove(a);
    }
}

a.doSomethingarayabilir Test.removeA();

İki seçenek:

• , Kaldırmak istediğiniz bir değerler listesi oluşturma ekleyerek döngü içinde bu listeye, daha sonra çağrı originalList.removeAll(valuesToRemove)sonunda
• remove()Yineleyicinin kendisindeki yöntemi kullanın . Bunun, gelişmiş for döngüsünü kullanamayacağınız anlamına geldiğini unutmayın.

İkinci seçeneğe örnek olarak, 5'ten büyük uzunluktaki dizeleri listeden kaldırmak:

List<String> list = new ArrayList<String>();
...
for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
    String value = iterator.next();
    if (value.length() > 5) {
        iterator.remove();
    }
}

ArrayList'in JavaDoc'larından

Bu sınıfın yineleyicisi ve listIterator yöntemleri tarafından döndürülen yineleyiciler hata hızındadır: liste yineleyici oluşturulduktan sonra herhangi bir zamanda yapısal olarak değiştirilirse , yineleyicinin kendi kaldırma veya ekleme yöntemleri dışında herhangi bir şekilde yineleyici bir ConcurrentModificationException özel durumu atar.

Herhangi bir hile uygulasanız bile (kodunuzda yaptığınız) gelişmiş "for loop" içindeki listeden değeri kaldırmaya çalışıyorsunuz. Daha iyi bir yol, burada önerildiği gibi tekrarlayıcı seviyesini kodlamaktır.

İnsanların döngü yaklaşımı için nasıl geleneksel önermediklerini merak ediyorum.

for( int i = 0; i < lStringList.size(); i++ )
{
    String lValue = lStringList.get( i );
    if(lValue.equals("_Not_Required"))
    {
         lStringList.remove(lValue);
         i--; 
    }  
}

Bu da işe yarıyor.

Gerçekten diziyi geleneksel şekilde tekrar etmelisiniz

Bir öğeyi listeden her kaldırışınızda, sonraki öğeler ileriye doğru itilir. Yinelemeden başka öğeleri değiştirmediğiniz sürece, aşağıdaki kodun çalışması gerekir.

public class Test(){
    private ArrayList<A> abc = new ArrayList<A>();

    public void doStuff(){
        for(int i = (abc.size() - 1); i >= 0; i--) 
            abc.get(i).doSomething();
    }

    public void removeA(A a){
        abc.remove(a);
    }
}

Java 8'de, Koleksiyon Arayüzünü kullanabilir ve removeIf yöntemini çağırarak bunu yapabilirsiniz:

yourList.removeIf((A a) -> a.value == 2);

Daha fazla bilgiyi burada bulabilirsiniz

Döngüyü normal şekilde yapın, java.util.ConcurrentModificationExceptionerişilen öğelerle ilgili bir hatadır.

O zaman dene:

for(int i = 0; i < list.size(); i++){
    lista.get(i).action();
}

Listeyi yinelerken, öğeyi kaldırmak istiyorsanız mümkündür. Aşağıdaki örneklerime bakalım,

ArrayList<String>  names = new ArrayList<String>();
        names.add("abc");
        names.add("def");
        names.add("ghi");
        names.add("xyz");

Array listesinin yukarıdaki isimlerine sahibim. Ve yukarıdaki listeden "def" adını kaldırmak istiyorum,

for(String name : names){
    if(name.equals("def")){
        names.remove("def");
    }
}

Yukarıdaki kod , yineleme sırasında listeyi değiştirdiğiniz için ConcurrentModificationException özel durumunu atar .

Böylece, "def" adını Arraylist'ten bu yolla kaldırmak için,

Iterator<String> itr = names.iterator();            
while(itr.hasNext()){
    String name = itr.next();
    if(name.equals("def")){
        itr.remove();
    }
}

Yukarıdaki kod, yineleyici aracılığıyla Arraylist "def" adını kaldırabilir ve dizi yazdırmaya çalışın, aşağıdaki çıktı göreceksiniz.

Çıktı: [abc, ghi, xyz]

Bir seçenek, removeAyöntemi bu şekilde değiştirmektir -

public void removeA(A a,Iterator<A> iterator) {
     iterator.remove(a);
     }

Ancak bu , yönteme doSomething()geçebilmeniz gerektiği anlamına gelir . Çok iyi bir fikir değil.iteratorremove

Bunu iki adımlı bir yaklaşımla yapabilir misiniz: Listenin üzerinde tekrarladığınız ilk döngüde, seçilen öğeleri kaldırmak yerine, silinecek olarak işaretleyin . Bunun için bu öğeleri (sığ kopya) diğerine kopyalayabilirsiniz .List

Ardından, yinelemeniz tamamlandığında, removeAllikinci listeden tüm öğeleri ilk listeden bir yapın.

Burada, kaldırılacak nesneleri eklemek için farklı bir liste kullandığım, daha sonra orijinal listeden öğeleri kaldırmak için stream.foreach kullandığım bir örnek:

private ObservableList<CustomerTableEntry> customersTableViewItems = FXCollections.observableArrayList();
...
private void removeOutdatedRowsElementsFromCustomerView()
{
    ObjectProperty<TimeStamp> currentTimestamp = new SimpleObjectProperty<>(TimeStamp.getCurrentTime());
    long diff;
    long diffSeconds;
    List<Object> objectsToRemove = new ArrayList<>();
    for(CustomerTableEntry item: customersTableViewItems) {
        diff = currentTimestamp.getValue().getTime() - item.timestamp.getValue().getTime();
        diffSeconds = diff / 1000 % 60;
        if(diffSeconds > 10) {
            // Element has been idle for too long, meaning no communication, hence remove it
            System.out.printf("- Idle element [%s] - will be removed\n", item.getUserName());
            objectsToRemove.add(item);
        }
    }
    objectsToRemove.stream().forEach(o -> customersTableViewItems.remove(o));
}

Kullanmak yerine Her döngü için döngü için normal kullanın. örneğin, aşağıdaki kod, java.util.ConcurrentModificationException vermeden dizi listesindeki tüm öğeleri kaldırır. Kullanım durumunuza göre döngüdeki koşulu değiştirebilirsiniz.

   for(int i=0;i<abc.size();i++)  {

          e.remove(i);
        }

Böyle basit bir şey yapın:

for (Object object: (ArrayList<String>) list.clone()) {
    list.remove(object);
}

Stream kullanan alternatif bir Java 8 çözümü:

        theList = theList.stream()
            .filter(element -> !shouldBeRemoved(element))
            .collect(Collectors.toList());

Java 7'de Guava'yı kullanabilirsiniz:

        theList = FluentIterable.from(theList)
            .filter(new Predicate<String>() {
                @Override
                public boolean apply(String element) {
                    return !shouldBeRemoved(element);
                }
            })
            .toImmutableList();

Guava örneğinin, istediğiniz gibi olabilecek veya olmayabilecek değişmez bir liste ile sonuçlandığını unutmayın.

ArrayList yerine CopyOnWriteArrayList'i de kullanabilirsiniz. JDK 1.5'ten itibaren önerilen en son yaklaşım budur.

Benim durumumda, kabul edilen cevap çalışmıyor, İstisnayı durdurur, ancak Listemde bazı tutarsızlıklara neden olur. Aşağıdaki çözüm benim için mükemmel çalışıyor.

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

for (String value: list) {
   if (value.length() > 5) { // your condition
       itemsToRemove.add(value);
   }
}
list.removeAll(itemsToRemove);

Bu kodda, başka bir listede kaldırmak için öğeleri ekledim ve sonra list.removeAllgerekli tüm öğeleri kaldırmak için yöntem kullandım .

"Önce listeyi klonlamalı mıyım?"

Bu en kolay çözüm olacaktır, klondan çıkarın ve klonu çıkardıktan sonra geri kopyalayın.

Rummikub oyunumdan bir örnek:

SuppressWarnings("unchecked")
public void removeStones() {
  ArrayList<Stone> clone = (ArrayList<Stone>) stones.clone();
  // remove the stones moved to the table
  for (Stone stone : stones) {
      if (stone.isOnTable()) {
         clone.remove(stone);
      }
  }
  stones = (ArrayList<Stone>) clone.clone();
  sortStones();
}

Amacınız listeden tüm öğeleri kaldırmaksa, her öğeyi tekrarlayabilir ve ardından şunu arayabilirsiniz:

list.clear()

Geç geldim biliyorum ama buna cevap veriyorum çünkü bu çözümün basit ve zarif olduğunu düşünüyorum:

List<String> listFixed = new ArrayList<String>();
List<String> dynamicList = new ArrayList<String>();

public void fillingList() {
    listFixed.add("Andrea");
    listFixed.add("Susana");
    listFixed.add("Oscar");
    listFixed.add("Valeria");
    listFixed.add("Kathy");
    listFixed.add("Laura");
    listFixed.add("Ana");
    listFixed.add("Becker");
    listFixed.add("Abraham");
    dynamicList.addAll(listFixed);
}

public void updatingListFixed() {
    for (String newList : dynamicList) {
        if (!listFixed.contains(newList)) {
            listFixed.add(newList);
        }
    }

    //this is for add elements if you want eraser also 

    String removeRegister="";
    for (String fixedList : listFixed) {
        if (!dynamicList.contains(fixedList)) {
            removeResgister = fixedList;
        }
    }
    fixedList.remove(removeRegister);
}

Tüm bunlar bir listeden diğerine güncelleme içindir ve hepsini tek bir listeden yapabilir ve yöntem güncellemesinde her iki listeyi de kontrol edebilir ve listeden öğeleri silebilir veya ekleyebilirsiniz. Bu, her iki listenin her zaman aynı boyutta olduğu anlamına gelir

Dizi Listesi yerine Yineleyici Kullan

Tür eşleşmesi ile bir kümenin yineleyiciye dönüştürülmesini sağlama

Ve bir sonraki öğeye geç ve kaldır

Iterator<Insured> itr = insuredSet.iterator();
while (itr.hasNext()) { 
    itr.next();
    itr.remove();
}

Burada sonrakine geçmek önemlidir, çünkü öğeyi kaldırmak için dizini almalıdır.

Ne hakkında

import java.util.Collections;

List<A> abc = Collections.synchronizedList(new ArrayList<>());

Sadece bir ekleme mola senin sonra ArrayList.remove (A) deyimi