List中remove()方法的陷阱，被坑惨了！

柔光的暖阳◎ 2022-08-28 01:49 140阅读 0赞

![314cf885c8d3b0e926b8f6a2d7d2ed6a.png][]

作者 | 倚楼听风雨

来源 | https://blog.csdn.net/pelifymeng2/article/details/78085836

Java的List在删除元素时，一般会用`list.remove(o)`/`remove(i)`方法。在使用时，容易触碰陷阱，得到意想不到的结果。总结以往经验，记录下来与大家分享。

首先初始化List，代码如下：

package com.cicc.am.test;
     
    import java.util.ArrayList;
    import java.util.List;
     
    public class ListTest {
     
     public static void main(String[] args) {
      List<Integer> list=new ArrayList<Integer>();
      list.add(1);
      list.add(2);
      list.add(3);
      list.add(3);
      list.add(4);
      System.out.println(list);
     }
    }

输出结果为\[1, 2, 3, 3, 4\]

**1、普通for循环遍历List删除指定元素--`错误`！！！**

for(int i=0;i<list.size();i++){
       if(list.get(i)==3) list.remove(i);
    }
    System.out.println(list);

输出结果：\[1, 2, 3, 4\]

为什么元素3只删除了一个？本以为这代码再简单不过，可还是掉入了陷阱里，上面的代码这样写的话，元素3是过滤不完的。只要list中有相邻2个相同的元素，就过滤不完。

List调用remove(index)方法后，会移除index位置上的元素，index之后的元素就全部依次左移，即索引依次-1要保证能操作所有的数据，需要把index-1，否则原来索引为index+1的元素就无法遍历到(因为原来索引为index+1的数据，在执行移除操作后，索引变成index了，如果没有index-1的操作，就不会遍历到该元素，而是遍历该元素的下一个元素)。

如果这样，删除元素后同步调整索引或者倒序遍历删除元素，是否可行呢？

**2、for循环遍历List删除元素时，让索引同步调整--`正确`！**

for(int i=0;i<list.size();i++){
       if(list.get(i)==3) list.remove(i--);
    }
    System.out.println(list);

输出结果：\[1, 2, 4\]

**3、倒序遍历List删除元素--`正确`！**

for(int i=list.size()-1;i>=0;i--){
     if(list.get(i)==3){
      list.remove(i);
     }
    }
    System.out.println(list);

输出结果：\[1, 2, 4\]

**4、foreach遍历List删除元素--`错误`！！！**

for(Integer i:list){
        if(i==3) list.remove(i);
    }
    System.out.println(list);

抛出异常：`java.util.ConcurrentModificationException`

`如果您正在学习Spring Boot，推荐一个连载多年还在继续更新的免费教程：http://blog.didispace.com/spring-boot-learning-2x/`

foreach 写法实际上是对的 Iterable、hasNext、next方法的简写。因此从`List.iterator()`源码着手分析，跟踪`iterator()`方法，该方法返回了 Itr 迭代器对象。

public Iterator<E> iterator() {
            return new Itr();
        }

Itr 类定义如下：

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;
     
            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();
                }
            }
     
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }

通过代码我们发现 Itr 是 ArrayList 中定义的一个私有内部类，在 next、remove方法中都会调用checkForComodification 方法，该方法的 作用是判断 `modCount != expectedModCount`是否相等，如果不相等则抛出`ConcurrentModificationException`异常。

每次正常执行 remove 方法后，都会对执行`expectedModCount = modCount`赋值，保证两个值相等，那么问题基本上已经清晰了，在 foreach 循环中执行 `list.remove(item);`，对 list 对象的 modCount 值进行了修改，而 list 对象的迭代器的 expectedModCount 值未进行修改，因此抛出了`ConcurrentModificationException`异常。

**5、迭代删除List元素--`正确`！**

java中所有的集合对象类型都实现了Iterator接口，遍历时都可以进行迭代：

Iterator<Integer> it=list.iterator();
     while(it.hasNext()){
      if(it.next()==3){
       it.remove();
      }
            }
    System.out.println(list);

输出结果：\[1, 2, 4\]

`Iterator.remove()` 方法会在删除当前迭代对象的同时，会保留原来元素的索引。所以用迭代删除元素是最保险的方法，建议大家使用List过程

中需要删除元素时，使用这种方式。

**6、迭代遍历,用list.remove(i)方法删除元素--`错误`！！！**

Iterator<Integer> it=list.iterator();
     while(it.hasNext()){
      Integer value=it.next();
       if(value==3){
       list.remove(value);
      }
     }
    System.out.println(list);

抛出异常：`java.util.ConcurrentModificationException`，原理同上述方法4.

**7、List删除元素时，注意Integer类型和int类型的区别.**

上述Integer的list,直接删除元素2，代码如下：

list.remove(2);
    System.out.println(list);

输出结果：\[1, 2, 3, 4\]

另外，如果您正在学习Spring Cloud，推荐一个连载多年还在继续更新的免费教程：https://blog.didispace.com/spring-cloud-learning/

可以看出,List删除元素时传入数字时，默认按索引删除。如果需要删除Integer对象，调用`remove(object)`方法，需要传入Integer类型，代码如下：

list.remove(new Integer(2));
    System.out.println(list);

输出结果：\[1, 3, 3, 4\]

**总结：**

1、用for循环遍历List删除元素时，需要注意索引会左移的问题。

2、List删除元素时，为避免陷阱，建议使用迭代器iterator的remove方式。

3、List删除元素时，默认按索引删除，而不是对象删除。

往期推荐

[一文带你入门 JMeter 性能测试！][JMeter]

[程序员的“鱿鱼游戏”，你能活到第几关？][Link 1]

[大名鼎鼎的 OceanBase 居然在买Star ！？][OceanBase _Star]

[支付宝员工因绩效3.25B被辞退，员工告上法院，结果来了！][3.25B]

[为什么 JSP 还没有被淘汰？][JSP]

**![e5e9ef4cd2f23587da7362262f849535.png][]技术交流群![6b37c9bbf9d706a6a01b342cad6a8ad4.png][]**

最近有很多人问，有没有读者交流群，想知道怎么加入。加入方式很简单，有兴趣的同学，只需要点击下方卡片，回复“**加群**“，即可免费加入我们的高质量技术交流群！

点击**阅读原文**，送你免费Spring Boot教程！

[314cf885c8d3b0e926b8f6a2d7d2ed6a.png]: /images/20220828/eaf06b9b553141e1a8052cdd9b8104f8.png
[JMeter]: http://mp.weixin.qq.com/s?__biz=MzAxODcyNjEzNQ==&mid=2247544494&idx=2&sn=1081a7859a302551c6b88efa58bdfd09&chksm=9bd38336aca40a2053a5764c07e2f9d525c5c0427ea881d5139d948da179bb1628d7f1fae326&scene=21#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzAxODcyNjEzNQ==&mid=2247544410&idx=1&sn=79c78be74d0c0102b625662413b4ff95&chksm=9bd383c2aca40ad43b66a9c677a7036fcab5020e82f4398b744fe9b7a31303951788946e53a8&scene=21#wechat_redirect
[OceanBase _Star]: http://mp.weixin.qq.com/s?__biz=MzAxODcyNjEzNQ==&mid=2247544356&idx=1&sn=a5a3183e3673ba2461def80dbf7e3682&chksm=9bd383bcaca40aaa468ea8248417e048280655a56ca9b6cdbb6161b4b5cad0f3d381e0f2f71c&scene=21#wechat_redirect
[3.25B]: http://mp.weixin.qq.com/s?__biz=MzAxODcyNjEzNQ==&mid=2247544201&idx=1&sn=b81847a64749ff3f32e1f0a8485e8e01&chksm=9bd38011aca409070ea31b3be5a6b456cb3f996ed38f90f871bb3aea8f1272f01dfbba8708ce&scene=21#wechat_redirect
[JSP]: http://mp.weixin.qq.com/s?__biz=MzAxODcyNjEzNQ==&mid=2247544118&idx=2&sn=ecab41b9f10401d9569342a4e47a52f6&chksm=9bd380aeaca409b8d98e888064fb09d87192538afb652493470637dca07963292d15a94ff636&scene=21#wechat_redirect
[e5e9ef4cd2f23587da7362262f849535.png]: https://img-blog.csdnimg.cn/img_convert/e5e9ef4cd2f23587da7362262f849535.png
[6b37c9bbf9d706a6a01b342cad6a8ad4.png]: /images/20220828/b1ea511b7ab449d0b2fa125de25c83a8.png