List集合遍历时如何删除元素

背景：在业务中遍历某个集合时涉及到排除某个属性为0的情况，即遍历时删除。

一、3种错误方式演示三种：

1.foreach

List<String> list = new ArrayList();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
for(String ele: list){
    if(ele.equals("3")){
        System.out.println(ele);
        list.remove(ele);
    }
}
System.out.println(list.size());

2.Iterator  

List<String> list = new ArrayList();
for (int i = 1; i <= 5; i++){
    list.add(i+"");
}
Iterator<String> iterator = list.iterator();
 while (iterator.hasNext()){
    String ele = iterator.next();
    if(ele.equals("3")){
        System.out.println(ele);
        list.remove(ele);
    }
 }
System.out.println(list.size());

以上两段代码的执行结果都是 java.util.ConcurrentModificationException。

在使用ArrayList时，当尝试用foreach或者Iterator遍历集合时进行删除或者插入元素的操作时，会抛出这样的异常：java.util.ConcurrentModificationException。

        关于这个异常的原因，详情请看https://blog.csdn.net/qq_33535433/article/details/90667425?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control简单来说就是：ArrayList的父类AbstarctList维护了一个属性modCount，我们每次对集合进行修改(增添、删除元素等)时，modCount都会+1。

        而以foreach本质上是使用iterator遍历，内部会生成一个迭代器iterator。在生成iterator的时候，会保存一个expectedModCount参数，这个是生成iterator的时候期望List中修改元素的次数，该变量初始时和modCount方法相等。如果你在遍历过程中删除元素，List中modCount就会变化。

在next方法中会调用checkForComodification()方法，若modCount != expectedModCount则会抛出java.util.ConcurrentModificationException异常，这是为了安全考虑。代码如下

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

 

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

既然上述方式都不行，那么用下标来遍历呢？即普通for循环

3.普通for循环

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(2);
        list.add(2);
        for(int i = 0; i < list.size(); i++){
            if(list.get(i) == 2){
                list.remove(i);
            }
        }
        System.out.println(list.size()); //结果为3
 /**
     * 循环流程：
     * 第一次循环：size = 5  i = 0  此时值为1
     * 第二次循环：size = 5  i = 1  此时值为2，删除后，size变为4
     * 第三次循环：size = 4  i = 2  此时值为2，删除后，size变为3
     * 第四次循环：size = 3，不符合条件，跳出循环，
     * 即随着你删除元素，list的大小也在自动变小，这不是我们所能控制的，
     * 即使将i < list.size()改为i < 5,也会报java.lang.IndexOutOfBoundsException，即超出边界
     */

二、解决办法

1.使用迭代器的remove方法

因为Iterator的remove方法中 有如下的操作：

expectedModCount = modCount；所以避免了ConcurrentModificationException的异常

 List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(2);
        list.add(2);
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            Integer ele = iterator.next();
            if(ele == 2){
                iterator.remove();
            }
        }
        System.out.println(list.size());

其中迭代器的remove相关代码如下：

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

   阿里巴巴Java开发手册中原话：不要在 foreach 循环里进行元素的 remove/add 操作。remove 元素请使用 Iterator方式，如果并发操作，需要对 Iterator 对象加锁。 

2.倒序遍历删除

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(2);
        list.add(2);
        for (int i = list.size() - 1; i >= 0; i--){
            if(list.get(i) == 2){
                list.remove(i);
            }
        }
        System.out.println(list.size());  //size 为1
        /**
         * 循环流程：
         * 第一次循环：size = 5  i = 4  此时值为2, 删除后，size变为4
         * 第二次循环：size = 4  i = 3  此时值为2，删除后，size变为3
         * 第三次循环：size = 3  i = 2  此时值为2，删除后，size变为2
         * 第四次循环：size = 2  i = 1  此时值为2，删除后，size变为1
         * 第五次循环：size = 1  i = 0  此时值为1超出边界
         */

可见，倒序遍历，每次删除一个元素size的改变未对遍历造成影响，且元素的前移也不会对倒序遍历有影响。最后两种方式修改集合均可，但集合存储大量的数据情况下，迭代器的速度更快