在遍历ArrayList并从中删除元素时如何避免java.util.ConcurrentModificationException

我有一个要迭代的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);
    }
}

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

公共类测试（）{
private ArrayList abc=new ArrayList（）；
公共空间{
对于（A:abc）
a、 doSomething（）；
}
公共空间移除A（A）{
abc.删除（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();
    }
}

List List=new ArrayList（）；
...
for（Iterator Iterator=list.Iterator（）；Iterator.hasNext（）；）{
字符串值=迭代器.next（）；
如果（value.length（）>5）{
iterator.remove（）；
}
}

来自ArrayList的JavaDocs

此类的迭代器和listIterator返回的迭代器 方法是快速失败的：如果列表在任何时候进行了结构修改 创建迭代器后的时间，以除通过 迭代器自己的删除或添加方法，迭代器将抛出 ConcurrentModificationException

---

一个选项是将

removeA

方法修改为-

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

public void removeA（A，迭代器迭代器）{
迭代器。删除（a）；
}

但是这意味着您的

doSomething（）

应该能够将

迭代器

传递给

remove

方法。这不是个好主意

您可以通过两步方法完成此操作： 在迭代列表的第一个循环中，不要删除选定的元素，而是将它们标记为要删除。为此，您可以简单地将这些元素（浅拷贝）复制到另一个

列表中

然后，迭代完成后，只需从第一个列表中删除第二个列表中的所有元素。
“我应该先克隆列表吗？”

这将是最简单的解决方案，从克隆中删除，然后在删除后将克隆复制回

我的rummikub游戏的一个例子：

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

SuppressWarnings（“未选中”）
公共资产转让{
ArrayList克隆=（ArrayList）stones.clone（）；
//把移到桌子上的石头移走
用于（石头：石头）{
if（stone.isOnTable（））{
克隆。移除（石头）；
}
}
stones=（ArrayList）clone.clone（）；
sortStones（）；
}
以下是一个示例，我使用不同的列表添加要删除的对象，然后使用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));
}

private observeList CustomerTableViewItems=FXCollections.observeArrayList（）；
...
private void RemoveOutDateDrowElementsFromCustomerView（）
{
ObjectProperty currentTimestamp=新的SimpleObject属性（TimeStamp.getCurrentTime（））；
长差；
长时间；
List objectsToRemove=new ArrayList（）；
用于（CustomerTableEntry项：CustomerTableViewItems）{
diff=currentTimestamp.getValue（）.getTime（）-item.timestamp.getValue（）.getTime（）；
diffSeconds=diff/1000%60；
如果（秒数>10）{
//元素已闲置太长时间，这意味着没有通信，因此请将其删除
System.out.printf（“-Idle元素[%s]-将被删除\n”，item.getUserName（））；
objectsToRemove.add（项）；
}
}
objectsToRemove.stream（）.forEach（o->CustomerTableViewItems.remove（o））；
}
您正在尝试从高级“for循环”中的列表中删除值，这是不可能的，即使您应用了任何技巧（在代码中这样做了）。
更好的方法是按照此处建议的其他方法编写迭代器级别的代码

我想知道人们怎么没有提出传统的for-loop方法

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

for（int i=0；i

这同样有效。
做一些简单的事情，比如：

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

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

（对象：（ArrayList）list.clone（）的
{
列表。删除（对象）；
}
你真的应该用传统的方法迭代数组

每次从列表中删除一个元素时，后面的元素都将被向前推。只要不更改迭代元素以外的其他元素，下面的代码就应该可以工作

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

公共类测试（）{
private ArrayList abc=new ArrayList（）；
公共空间{
对于（inti=（abc.size（）-1）；i>=0；i--）
abc.get（i）doSomething（）；
}
公共空间移除A（A）{
abc.删除（a）；
}
}
在Java 8中，您可以通过调用removeIf方法来使用Collection接口：

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

可以找到更多信息
以正常方式执行循环，
java.util.ConcurrentModificationException
是与所访问的元素相关的错误

因此，请尝试：

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

for（int i=0；i
使用流的替代Java 8解决方案：

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

在Java 7中，您可以使用番石榴：

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

theList=fluentitable.from（theList）
.filter（新谓词（）{
@凌驾
公共布尔应用（字符串元素）{
返回！应该被移动（e）
Iterator<String> itr = names.iterator();            
while(itr.hasNext()){
    String name = itr.next();
    if(name.equals("def")){
        itr.remove();
    }
}

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

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<Insured> itr = insuredSet.iterator();
while (itr.hasNext()) { 
    itr.next();
    itr.remove();
}

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

import java.util.Collections;

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

fun <T> MutableList<T>.mathList(_fun: (T) -> T): MutableList<T> {
    for (i in this) {
        this.add(_fun(i))   <---   ERROR
    }
    return this   <--- ERROR
}

fun <T> MutableList<T>.mathList(_fun: (T) -> T): MutableList<T> {
    val newList = mutableListOf<T>()   <---   DECISION
    for (i in this) {
        newList.add(_fun(i))   <---   DECISION
    }
    return newList   <---   DECISION
}

for (A a : new ArrayList<>(abc)) {
    a.doSomething();
    abc.remove(a);
}