I know this question assumes just a Collection, and not more specifically any List. But for those reading this question who are indeed working with a List reference, you can avoid ConcurrentModificationException with a while-loop (while modifying within it) instead if you want to avoid Iterator (either if you want to avoid it in general, or avoid it specifically to achieve a looping order different from start-to-end stopping at each element [which I believe is the only order Iterator itself can do]):

*更新:参见下面的注释，说明类似的情况也可以用传统的for循环实现。

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

该代码中没有ConcurrentModificationException。

在这里，我们看到循环没有从开始处开始，也没有在每个元素处停止(我相信Iterator本身不能做到这一点)。

在FWIW中，我们还看到get在list上被调用，如果它的引用只是Collection(而不是更具体的list类型的Collection)，则无法做到这一点——list接口包括get，但Collection接口不包括。如果不是因为这个区别，那么列表引用可以是一个集合[因此从技术上讲，这个答案将是一个直接答案，而不是一个切向答案]。

FWIWW相同的代码在修改为start at beginning at stop at每个元素后仍然有效(就像Iterator order一样):

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

线程安全集合修改示例:

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

I know this question assumes just a Collection, and not more specifically any List. But for those reading this question who are indeed working with a List reference, you can avoid ConcurrentModificationException with a while-loop (while modifying within it) instead if you want to avoid Iterator (either if you want to avoid it in general, or avoid it specifically to achieve a looping order different from start-to-end stopping at each element [which I believe is the only order Iterator itself can do]):

*更新:参见下面的注释，说明类似的情况也可以用传统的for循环实现。

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

该代码中没有ConcurrentModificationException。

在这里，我们看到循环没有从开始处开始，也没有在每个元素处停止(我相信Iterator本身不能做到这一点)。

在FWIW中，我们还看到get在list上被调用，如果它的引用只是Collection(而不是更具体的list类型的Collection)，则无法做到这一点——list接口包括get，但Collection接口不包括。如果不是因为这个区别，那么列表引用可以是一个集合[因此从技术上讲，这个答案将是一个直接答案，而不是一个切向答案]。

FWIWW相同的代码在修改为start at beginning at stop at每个元素后仍然有效(就像Iterator order一样):

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

当使用stream().map()方法迭代列表时，我最终得到了这个ConcurrentModificationException。但是，在迭代和修改列表时，for(:)没有抛出异常。

以下是代码片段，如果对任何人有帮助的话: 这里我在一个<BuildEntity>的ArrayList上迭代，并使用list.remove(obj)修改它

 for(BuildEntity build : uniqueBuildEntities){
            if(build!=null){
                if(isBuildCrashedWithErrors(build)){
                    log.info("The following build crashed with errors ,  will not be persisted -> \n{}"
                            ,build.getBuildUrl());
                    uniqueBuildEntities.remove(build);
                    if (uniqueBuildEntities.isEmpty()) return  EMPTY_LIST;
                }
            }
        }
        if(uniqueBuildEntities.size()>0) {
            dbEntries.addAll(uniqueBuildEntities);
        }

人们断言一个对象不能从foreach循环迭代的Collection中删除。我只是想指出这在技术上是不正确的，并准确地描述(我知道OP的问题非常高级，以至于不知道这一点)这个假设背后的代码:

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

这并不是说您不能从迭代的collection中删除，而是您一旦删除了collection就不能继续迭代。因此上面的代码出现了中断。

抱歉，如果这个答案是一个有点专业的用例，更适合于我到达这里的原始线程，那个被标记为这个的副本(尽管这个线程看起来更微妙)并锁定。

一种解决方案是旋转列表并删除第一个元素，以避免ConcurrentModificationException或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);