java中List元素移除元素的那些坑

本文主要介绍,java中list集合移除元素的那些坑,今天小编就和大家一起来了解一下吧!


一、问题案例


 1.1、for循环移除


 
 
public static void main(String[] args) {	
  List<String> list = new ArrayList<String>();	
  list.add("11");	
  list.add("11");	
  list.add("12");	
  list.add("13");	
  list.add("14");	
  list.add("15");	
  list.add("16");	
  System.out.println("原始list元素:"+ list.toString());	
  CopyOnWriteArrayList<String> copyList = new CopyOnWriteArrayList<>(list);	
  	
  //通过下表移除等于11的元素	
  for (int i = 0; i < list.size(); i++) {	
    String item = list.get(i);	
    if("11".equals(item)) {	
      list.remove(i);	
    }	
  }	
  System.out.println("通过下表移除后的list元素:"+ list.toString());	
  	
  //通过对象移除等于11的元素	
  for (int i = 0; i < copyList.size(); i++) {	
    String item = copyList.get(i);	
    if("11".equals(item)) {	
      copyList.remove(item);	
    }	
  }	
  System.out.println("通过对象移除后的list元素:"+ list.toString());	
  	
}


输出结果:


 
 
原始list元素:[11, 11, 12, 13, 14, 15, 16]	
通过下表移除后的list元素:[11, 12, 13, 14, 15, 16]	
通过对象移除后的list元素:[11, 12, 13, 14, 15, 16]


有没有发现有蹊跷的地方?


从输出结果可以看的出,移除后的元素,并没有把内容为 11 的都移除掉!


发生了什么?


删除了第一个 11 后,集合里的元素个数减1,后面的元素往前移了1位,此时,第二个 11 已经移到了索引 index=1的位置,而此时i马上i++了,list.get(i)获得的是数据  12 。同时 list.size() 的值也在减小。所以最后输出那个结果。


 
 
public static void main(String[] args) {	
  List<String> list = new ArrayList<String>();	
  list.add("11");	
  list.add("11");	
  list.add("12");	
  list.add("13");	
  list.add("14");	
  list.add("15");	
  list.add("16");	
  System.out.println("原始list元素:"+ list.toString());	
  	
  	
  //通过对象移除等于11的元素	
  for (String item : list) {	
    if("11".equals(item)) {	
      list.remove(item);	
    }	
  }	
  System.out.println("通过对象移除后的list元素:"+ list.toString());	
  	
}


输出结果:


640?wx_fmt=jpeg


抛ConcurrentModificationException异常!


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


找到  List  的迭代器类


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


通过代码我们发现 Itr ArrayList 中定义的一个私有内部类,在 nextremove方法中都会调用 checkForComodification 方法,该方法的作用是判断 modCount != expectedModCount是否相等,如果不相等则抛出ConcurrentModificationException异常。每次正常执行 remove 方法后,都会对执行 expectedModCount = modCount 赋值,保证两个值相等!


那么问题基本上已经清晰了,在 foreach 循环中执行 list.remove(item);,对 list 对象的 modCount 值进行了修改,而 list 对象的迭代器的 expectedModCount 值未进行修改,因此抛出了ConcurrentModificationException 异常。


 二、解决办法


2.1、采用倒序移除


 
 
public static void main(String[] args) {	
  List<String> list = new ArrayList<String>();	
  list.add("11");	
  list.add("11");	
  list.add("12");	
  list.add("13");	
  list.add("14");	
  list.add("15");	
  list.add("16");	
  System.out.println("原始list元素:"+ list.toString());	
  CopyOnWriteArrayList<String> copyList = new CopyOnWriteArrayList<>(list);	
  	
  //通过下表移除等于11的元素	
  for (int i = list.size() - 1; i >= 0; i--) {	
    String item = list.get(i);	
    if("11".equals(item)) {	
      list.remove(i);	
    }	
  }	
  System.out.println("通过下表移除后的list元素:"+ list.toString());	
  	
  //通过对象移除等于11的元素	
  for (int i = copyList.size() - 1; i >= 0; i--) {	
    String item = copyList.get(i);	
    if("11".equals(item)) {	
      copyList.remove(item);	
    }	
  }	
  System.out.println("通过对象移除后的list元素:"+ list.toString());	
  	
}


输出结果:


 
 
原始list元素:[11, 11, 12, 13, 14, 15, 16]	
通过下表移除后的list元素:[12, 13, 14, 15, 16]	
通过对象移除后的list元素:[12, 13, 14, 15, 16]


2.2、fore的解决办法


 
 
public static void main(String[] args) {	
  List<String> list = new ArrayList<String>();	
  list.add("11");	
  list.add("11");	
  list.add("12");	
  list.add("13");	
  list.add("14");	
  list.add("15");	
  list.add("16");	
  System.out.println("原始list元素:"+ list.toString());	
  CopyOnWriteArrayList<String> copyList = new CopyOnWriteArrayList<>(list);	
  	
  //通过对象移除等于11的元素	
  for (String item : copyList) {	
    if("11".equals(item)) {	
      copyList.remove(item);	
    }	
  }	
  System.out.println("通过对象移除后的list元素:"+ copyList.toString());	
  	
}


输出结果:


 
 
原始list元素:[11, 11, 12, 13, 14, 15, 16]	
通过对象移除后的list元素:[12, 13, 14, 15, 16]


2.3、使用迭代器移除


 
 
public static void main(String[] args) {	
  List<String> list = new ArrayList<String>();	
  list.add("11");	
  list.add("11");	
  list.add("12");	
  list.add("13");	
  list.add("14");	
  list.add("15");	
  list.add("16");	
  System.out.println("原始list元素:"+ list.toString());	
  	
  //通过迭代器移除等于11的元素	
  Iterator<String> iterator = list.iterator();	
  while(iterator.hasNext()) {	
    String item = iterator.next();	
    if("11".equals(item)) {	
      iterator.remove();	
    }	
  }	
  System.out.println("通过迭代器移除后的list元素:"+ list.toString());	
  	
}


输出结果:


 
 
原始list元素:[11, 11, 12, 13, 14, 15, 16]	
通过迭代器移除后的list元素:[12, 13, 14, 15, 16]


2.4、jdk1.8的写法


 
 
public static void main(String[] args) {	
  List<String> list = new ArrayList<String>();	
  list.add("11");	
  list.add("11");	
  list.add("12");	
  list.add("13");	
  list.add("14");	
  list.add("15");	
  list.add("16");	
  System.out.println("原始list元素:"+ list.toString());	
  	
  //jdk1.8移除等于11的元素	
  list.removeIf(item -> "11".equals(item));	
  System.out.println("移除后的list元素:"+ list.toString());	
  	
}


输出结果:


 
 
原始list元素:[11, 11, 12, 13, 14, 15, 16]	
通过迭代器移除后的list元素:[12, 13, 14, 15, 16]


是不是好简单,哈哈!


三、总结


如果开发中需要在集合中移除某个元素,如果jdk是1.8的,建议直接使用2.4方法,如果是低版本,那么建议采用迭代器方法,效率高,性能好!


四、参考


部分内容参考:[cdsn那是2008](https://blog.csdn.net/claram/article/details/53410175)




往期精彩回顾:

Spring系列:

spring 注解编程之注解属性别名与覆盖

Spring 注解编程之 AnnotationMetadata

Spring 源码学习(五) 循环依赖

640?wx_fmt=jpeg

于加入知识星球的同学提供基本的福利:

文章有疑问的地方可以提问,其他工作问题都可以提问出来,作者免费作答。

 https://t.zsxq.com/Y3fYny7


每周都有大牛分享一些面试题,和面试注意的知识点!

 https://t.zsxq.com/2bufE2v


每周由Java极客技术独家编制的设计模式与大家分享!

 https://t.zsxq.com/3bUNbEI


每两周还会分享一个话题,和大家一起成长!

 https://t.zsxq.com/BI6Unm2


还有Java极客技术团队亲自录制了一套 Spring Boot 视频,这套视频加密,加密后放到云盘上,下载链接加密之后,一机一码,每个星球的用户一个播放授权码。

 

我们做知识星球的目的和其他星主一样,就是为了帮助大家一起更好的成长,与高手拉近距离,减少差距,其实你也是高手!

640?wx_fmt=png 640?wx_fmt=jpeg 640?wx_fmt=jpeg 640?wx_fmt=jpeg 640?wx_fmt=jpeg

1000人,50元/每年,现在大约还剩487名额。

长按二维码

640?wx_fmt=png

隆重介绍:

Java 极客技术公众号,是由一群热爱 Java 开发的技术人组建成立,专注分享原创、高质量的 Java 文章。如果您觉得我们的文章还不错,请帮忙赞赏、在看、转发支持,鼓励我们分享出更好的文章。


640?wx_fmt=jpeg

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值