foreach中不允许对元素进行add和remove底层原理

  @Test
    public void ArrayList(){
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i <10; i++) {
            list.add(i);
        }
        for (Integer integer : list) {
           if(integer==3){
               list.remove(integer);
           }
            System.out.println(integer);
        }
    }

@Test
    public void ArrayList(){
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i <10; i++) {
            list.add(i);
        }
        System.out.println("没有删除元素前"+list.toString());
        //使用迭代器的方向进行remove、add
        ListIterator<Integer> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            Integer integer = listIterator.next();
            if(integer==3){
                listIterator.remove();
                listIterator.add(11);
            }
        }
        System.out.println("删除元素后"+list.toString());
    }

在很多应用场景中，读操作可能会远远大于写操作。由于读操作根本不会修改原有的数据，
因此如果每次读取都进行加锁操作，其实是一种资源浪费。
我们应该允许多个线程同时访问 List 的内部数据，毕竟读操作是线程安全的。
这和 ReentrantReadWriteLock 读写锁的思想非常类似，
也就是 读读共享、写写互斥、读写互斥、写读互斥。
JDK中提供了 CopyOnWriteArrayList 类，
相比于在读写锁的思想又更进一步。为了将读取的性能发挥到极致，
CopyOnWriteArrayList 读取是完全不用加锁的，并且更厉害的是：
写入也不会阻塞读取操作，只有写入和写入之间需要进行同步等待，读操作的性能得到大幅度提升。

    @Test
    public void copyOnWriteArrayList(){
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i <5; i++) {
            list.add(i);
        }
        System.out.println("没有删除元素前"+list);
        for (Integer integer : list) {
            if(integer==3){
                list.remove(integer);
                list.add(10);
            }
        }
        System.out.println("删除元素后"+list);
    }

public boolean add(E e) {
    // 可重入锁
    final ReentrantLock lock = this.lock;
    // 获取锁
    lock.lock();
    try {
        // 元素数组
        Object[] elements = getArray();
        // 数组长度
        int len = elements.length;
        // 复制数组
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        // 存放元素e
        newElements[len] = e;
        // 设置数组
        setArray(newElements);
        return true;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

1.获取锁(保证多线程的安全访问)，获取当前的Object数组，获取Object数组的长度为length，进入步骤②。
2.根据Object数组复制一个长度为length+1的Object数组为newElements
   (此时，newElements[length]为null)，进入下一步骤。
3.将下标为length的数组元素newElements[length]设置为元素e，
  再设置当前Object[]为newElements，释放锁，返回。这样就完成了元素的添加。

public E remove(int index) {
    // 可重入锁
    final ReentrantLock lock = this.lock;
    // 获取锁
    lock.lock();
    try {
        // 获取数组
        Object[] elements = getArray();
        // 数组长度
        int len = elements.length;
        // 获取旧值
        E oldValue = get(elements, index);
        // 需要移动的元素个数
        int numMoved = len - index - 1;
        if (numMoved == 0) // 移动个数为0
            // 复制后设置数组
            setArray(Arrays.copyOf(elements, len - 1));
        else { // 移动个数不为0
            // 新生数组
            Object[] newElements = new Object[len - 1];
            // 复制index索引之前的元素
            System.arraycopy(elements, 0, newElements, 0, index);
            // 复制index索引之后的元素
            System.arraycopy(elements, index + 1, newElements, index,
                                numMoved);
            // 设置索引
            setArray(newElements);
        }
        // 返回旧值
        return oldValue;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

1.获取锁，获取数组elements，数组长度为length，获取索引的值elements[index]，
  计算需要移动的元素个数(length - index - 1),若个数为0，则表示移除的是数组的最后一个元素，
  复制elements数组，复制长度为length-1，然后设置数组，进入步骤③；否则，进入步骤②
2.先复制index索引前的元素，再复制index索引后的元素，然后设置数组。
3.释放锁，返回旧值。