Как избежать java.util.ConcurrentModificationException при переборе и удалении элементов из ArrayList

У меня есть ArrayList, который я хочу перебрать. Итерируя по нему, я должен удалить элементы одновременно. Очевидно, это бросает java.util.ConcurrentModificationException.

Какова лучшая практика для решения этой проблемы? Должен ли я сначала клонировать список?

Я удаляю элементы не в самом цикле, а в другой части кода.

Мой код выглядит так:

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.doSomethingможет позвонить Test.removeA();

Два варианта:

• Создайте список значений, которые вы хотите удалить, добавив в этот список в цикле, а затем вызовите originalList.removeAll(valuesToRemove)в конце
• Используйте remove()метод на самом итераторе. Обратите внимание, что это означает, что вы не можете использовать расширенный цикл for.

В качестве примера второй опции, удаляем любые строки длиной более 5 из списка:

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

Из JavaDocs ArrayList

Итераторы, возвращаемые методами итератора и listIterator этого класса, не подвержены сбоям: если список структурно изменяется в любое время после создания итератора, любым способом, кроме использования собственных методов удаления или добавления итератора, итератор создает исключение ConcurrentModificationException.

Вы пытаетесь удалить значение из списка в расширенном цикле for, что невозможно, даже если вы применили какой-то трюк (который вы сделали в своем коде). Лучше всего кодировать уровень итератора, как советуют другие.

Интересно, как люди не предложили традиционный для петли подход.

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

Это работает также.

Вы действительно должны просто итерировать массив традиционным способом

Каждый раз, когда вы удаляете элемент из списка, элементы после будут перемещаться вперед. Пока вы не измените элементы, отличные от итеративного, следующий код должен работать.

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 вы можете использовать интерфейс коллекции и сделать это, вызвав метод removeIf:

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

Более подробную информацию можно найти здесь

Выполните цикл обычным способом, java.util.ConcurrentModificationExceptionэто ошибка, связанная с элементами, к которым осуществляется доступ.

Поэтому постарайтесь:

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

Во время итерации списка, если вы хотите удалить элемент, это возможно. Давай посмотрим ниже мои примеры,

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

У меня есть вышеупомянутые имена списка Array. И я хочу удалить имя "def" из списка выше,

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

Приведенный выше код вызывает исключение ConcurrentModificationException, поскольку вы изменяете список во время итерации.

Таким образом, чтобы удалить имя "def" из Arraylist, сделав так,

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

Приведенный выше код, через итератор, мы можем удалить имя «def» из Arraylist и попытаться напечатать массив, вы увидите вывод ниже.

Вывод: [abc, ghi, xyz]

Одним из вариантов является изменение removeAметода для этого -

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

Но это означает , что ваш doSomething()должен быть в состоянии пройти iteratorк removeметоду. Не очень хорошая идея.

Вы можете сделать это в два этапа: в первом цикле, когда вы перебираете список, вместо удаления выбранных элементов, пометьте их как подлежащие удалению . Для этого вы можете просто скопировать эти элементы (поверхностное копирование) в другой List.

Затем, как только ваша итерация будет завершена, просто сделайте removeAllиз первого списка все элементы второго списка.

Вот пример, в котором я использую другой список для добавления объектов для удаления, а затем я использую stream.foreach для удаления элементов из исходного списка:

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

Вместо использования Для каждого цикла используйте обычный цикл for. например, приведенный ниже код удаляет все элементы в списке массивов без предоставления исключения java.util.ConcurrentModificationException. Вы можете изменить условие в цикле в соответствии с вашим вариантом использования.

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

          e.remove(i);
        }

Сделайте что-нибудь простое, например:

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

Альтернативное решение Java 8 с использованием потока:

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

В Java 7 вы можете использовать вместо Guava:

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

Обратите внимание, что пример Guava приводит к неизменному списку, который может или не может быть тем, что вы хотите.

Вы также можете использовать CopyOnWriteArrayList вместо ArrayList. Это последний рекомендуемый подход, начиная с версии 1.5.

В моем случае принятый ответ не работает, он останавливает исключение, но вызывает некоторые противоречия в моем списке. Следующее решение отлично работает для меня.

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

В этом коде я добавил элементы для удаления в другой список, а затем использовал list.removeAllметод для удаления всех необходимых элементов.

"Должен ли я сначала клонировать список?"

Это будет самое простое решение, удалить из клона и скопировать клон обратно после удаления.

Пример из моей игры в руммикуб:

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

Если ваша цель - удалить все элементы из списка, вы можете выполнить итерацию по каждому элементу, а затем вызвать:

list.clear()

Я опаздываю, я знаю, но я отвечаю на это, потому что я думаю, что это простое и элегантное решение:

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

Все это для обновления из одного списка в другой, и вы можете сделать все из одного списка, а при обновлении метода вы проверяете оба списка и можете стирать или добавлять элементы между списками. Это означает, что оба списка всегда одного размера

Используйте Iterator вместо Array List

Пусть набор будет преобразован в итератор с типом соответствия

И перейти к следующему элементу и удалить

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

Здесь важно перейти к следующему, так как для удаления элемента необходим индекс.

Как насчет

import java.util.Collections;

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

Просто добавьте разрыв после вашего заявления ArrayList.remove (A)