java：foreach中为何不允许对元素进行add和remove

java：foreach中为何不允许对元素进行add和remove

1 举例ArrayList：

package com.base2;

import java.util.ArrayList;
import java.util.List;

public class ArrF {
    public static void main(String[] args) {
        List<String> l=new ArrayList<>();
        //元素放入list中
        for (int i=0;i<4;i++){
            l.add(String.valueOf(i));
        }
        for (String s : l) {
            if("3".equals(s)){
                l.remove(3);
            }
            System.out.println(s);
        }
    }
}

改用迭代器，还是抛错：

public static void main(String[] args) {
    //使用迭代器遍历
    List<String> l=new ArrayList<>();
    for (int i=0;i<4;i++){
        l.add(String.valueOf(i));
    }
    Iterator<String> iter=l.iterator();
    while (iter.hasNext()){
        String s= iter.next();
        if(s.equals("1")){
            l.remove(1); //注意这里
        }
        System.out.println(s);
    }
}

对于modCount的提示，modCount是AbstractList类中的一个成员变量，表示此列表在结构上被修改的次数，提供了一种快速失效行为（fail-fast）。

观察remove方法是否对该变量进行了增减：



add也类似remove：

这里只有modCount，还需要找到expectedModCount：

源码如下：

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    Itr() {}

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }

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

实际上，int expectedModCount = modCount；初始的expectedModCount 就是modCount，上面的类的next和remove都调用了checkForComodification，即是说，expectedModCount 初始值是modCount，但是并未改变，只要在foreach中调用add或remove方法，就会导致expectedModCount 和modCount不一致，抛错，即fail-fast，快速检测失败机制。

1.1 修改上面的迭代器remove：

public static void main(String[] args) {
    //使用迭代器遍历
    List<String> l=new ArrayList<>();
    for (int i=0;i<4;i++){
        l.add(String.valueOf(i));
    }
    Iterator<String> iter=l.iterator();
    while (iter.hasNext()){
        String s= iter.next();
        if(s.equals("1")){
//                l.remove(1); //注意这里
            iter.remove();//注意这里
        }
    }
    System.out.println("删除后的list："+l.toString());
}

删除后的list：[0, 2, 3]

这种方式可以实现在foreach中add和remove操作

2 第2种方式实现foreach中add和remove

CopyOnWriteArrayList类可以解决fail-fast问题：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

public class ArrF {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> l=new CopyOnWriteArrayList<>();
        for (int i=0;i<4;i++){
            l.add(String.valueOf(i));
        }
        System.out.println("没有删除元素前："+l.toString());
        Iterator<String> iter=l.iterator();
        while (iter.hasNext()){
            String s=iter.next();
            if(s.equals("1")){
                l.remove(1);
            }
        }
        System.out.println("删除元素后："+l.toString());
    }
}

没有删除元素前：[0, 1, 2, 3]
删除元素后：[0, 2, 3]

实际上，CopyOnWriteArrayList是通过复制来实现的，所以并不推荐。因为复制会出现两个存储相同内容的空间，消耗了空间，进行GC的时候，也需要时间去清理它。 推荐使用迭代器对象.remove()的方式。