Java中ArrayList在foreach里remove的问题详析

前言

ArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了如下一些好处:

  • 动态的增加和减少元素
  • 实现了ICollection和IList接口
  • 灵活的设置数组的大小

都说ArrayList在用foreach循环的时候,不能add元素,也不能remove元素,可能会抛异常,那我们就来分析一下它具体的实现。我目前的环境是Java8。

有下面一段代码:

public class TestForEachList extends BaseTests {

 @Test
 public void testForeach() {
 List<String> list = new ArrayList<>();
 list.add("1");
 list.add("2");
 list.add("3");

 for (String s : list) {
 }
 }

}

代码很简单,一个ArrayList添加3个元素,foreach循环一下,啥都不干。那么foreach到底是怎么实现的呢,暴力的方法看一下,编译改类,用 javap -c TestForEachList查看class文件的字节码,如下:

javap -c TestForEachList
Warning: Binary file TestForEachList contains collection.list.TestForEachList
Compiled from "TestForEachList.java"
public class collection.list.TestForEachList extends com.ferret.BaseTests {
 public collection.list.TestForEachList();
 Code:
 0: aload_0
 1: invokespecial #1  // Method com/ferret/BaseTests."<init>":()V
 4: return

 public void testForeach();
 Code:
 0: new #2  // class java/util/ArrayList
 3: dup
 4: invokespecial #3  // Method java/util/ArrayList."<init>":()V
 7: astore_1
 8: aload_1
 9: ldc #4  // String 1
 11: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
 16: pop
 17: aload_1
 18: ldc #6  // String 2
 20: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
 25: pop
 26: aload_1
 27: ldc #7  // String 3
 29: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
 34: pop
 35: aload_1
 36: invokeinterface #8, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
 41: astore_2
 42: aload_2
 43: invokeinterface #9, 1 // InterfaceMethod java/util/Iterator.hasNext:()Z
 48: ifeq 64
 51: aload_2
 52: invokeinterface #10, 1 // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
 57: checkcast #11  // class java/lang/String
 60: astore_3
 61: goto 42
 64: return
}

可以勉强读,大约是调用了List.iterator,然后根据iterator的hasNext方法返回结果判断是否有下一个,根据next方法取到下一个元素。

但是是总归是体验不好,我们是现代人,所以用一些现代化的手段,直接用idea打开该class文件自动反编译,得到如下内容:

public class TestForEachList extends BaseTests {
 public TestForEachList() {
 }

 @Test
 public void testForeach() {
 List<String> list = new ArrayList();
 list.add("1");
 list.add("2");
 list.add("3");

 String var3;
 for(Iterator var2 = list.iterator(); var2.hasNext(); var3 = (String)var2.next()) {
 ;
 }

 }
}

体验好多了,再对比上面的字节码文件,没错

for(Iterator var2 = list.iterator(); var2.hasNext(); var3 = (String)var2.next()) {
 ;
 }

这就是脱掉语法糖外壳的foreach的真正实现。

接下来我们看看这三个方法具体都是怎么实现的:

iterator

ArrayList的iterator实现如下:

public Iterator<E> iterator() {
 return new 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是ArrayList中的内部类,所以list.iterator()的作用是返回了一个Itr对象赋值到var2,后面调用var2.hasNext()var2.next()就是Itr的具体实现了。

这里还值的一提的是expectedModCount, 这个变量记录被赋值为modCount, modCount是ArrayList的父类AbstractList的一个字段,这个字段的含义是list结构发生变更的次数,通常是add或remove等导致元素数量变更的会触发modCount++。

下面接着看itr.hasNext()``var2.next()的实现。

itr.hasNext 和 itr.next 实现

hasNext很简单

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

当前index不等于size则说明还没迭代完,这里的size是外部类ArrayList的字段,表示元素个数。

在看next实现:

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

next方法第一步 checkForComodification() ,它做了什么? 如果modCount != expectedModCount就抛出异常ConcurrentModificationException。modCount是什么?外部类ArrayList的元素数量变更次数;expectedModCount是什么?初始化内部类Itr的时候外部类的元素数量变更次数。

所以,如果在foreach中做了add或者remove操作会导致程序异常ConcurrentModificationException。这里可以走两个例子:

 @Test(expected = ConcurrentModificationException.class)
 public void testListForeachRemoveThrow() {
 List<String> list = new ArrayList<>();
 list.add("1");
 list.add("2");
 list.add("3");

 for (String s : list) {
 list.remove(s);
 }
 }

 @Test(expected = ConcurrentModificationException.class)
 public void testListForeachAddThrow() {
 List<String> list = new ArrayList<>();
 list.add("1");
 list.add("2");
 list.add("3");

 for (String s : list) {
 list.add(s);
 }
 }

单元测试跑过,都抛了ConcurrentModificationException。

checkForComodification()之后的代码比较简单这里就不分析了。

倒数第二个元素的特殊

到这里我们来捋一捋大致的流程:

获取到Itr对象赋值给var2

判断hasNext,也就是判断cursor != size,当前迭代元素下标不等于list的个数,则返回true继续迭代;反之退出循环

next取出迭代元素

  • checkForComodification() ,判断modCount != expectedModCount,元素数量变更次数不等于初始化内部类Itr的时元素变更次数,也就是在迭代期间做过修改就抛ConcurrentModificationException。
  • 如果检查通过cursor++

下面考虑一种情况:remove了倒数第二个元素会发生什么?代码如下:

@Test
public void testListForeachRemoveBack2NotThrow() {
 List<String> list = new ArrayList<>();
 list.add("1");
 list.add("2");
 list.add("3");

 for (String s : list) {
 System.out.println(s);
 if ("2".equals(s)) {
 list.remove(s);
 }
 }
}

猜一下会抛出异常吗?答案是否定的。输出为:

1
2

发现少了3没有输出。 分析一下

在倒数第二个元素"2"remove后,list的size-1变为了2,而此时itr中的cur在next方法中取出元素"2"后,做了加1,值变为2了,导致下次判断hasNext时,cursor==size,hasNext返回false,最终最后一个元素没有被输出。

如何避坑

foreach中remove 或 add 有坑,

  • 在foreach中做导致元素个数发生变化的操作(remove, add等)时,会抛出ConcurrentModificationException异常
  • 在foreach中remove倒数第二个元素时,会导致最后一个元素不被遍历

那么我们如何避免呢?不能用foreach我们就用fori嘛,如下代码:

@Test
 public void testListForiMiss() {
 List<String> list = new ArrayList<>();
 list.add("1");
 list.add("2");
 list.add("3");

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

很明显上面是一个错误的示范,输出如下:

1
3

原因很简单,原来的元素1被remove后,后面的向前拷贝,2到了原来1的位置(下标0),3到了原来2的位置(下标1),size由3变2,i+1=1,输出list.get(1)就成了3,2被漏掉了。

下面说下正确的示范:

方法一,还是fori,位置前挪了减回去就行了, remove后i--:

@Test
 public void testListForiRight() {
 List<String> list = new ArrayList<>();
 list.add("1");
 list.add("2");
 list.add("3");

 for (int i = 0; i < list.size(); i++) {
  System.out.println(list.get(i));
  list.remove(i);
  i--; //位置前挪了减回去就行了
 }
 }

方法二,不用ArrayList的remove方法,用Itr自己定义的remove方法,代码如下:

@Test
 public void testIteratorRemove() {
 List<String> list = new ArrayList<>();
 list.add("1");
 list.add("2");
 list.add("3");

 Iterator<String> itr = list.iterator();
 while (itr.hasNext()) {
  String s = itr.next();
  System.out.println(s);
  itr.remove();
 }
 }

为什么itr自己定义的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();
  }
 }

依然有 checkForComodification()校验,但是看到后面又重新赋值了,所以又相等了。

ok,以上就是全部内容。介绍了foreach中list remove的坑,以及如何避免。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对我们的支持。

(0)

相关推荐

  • Java ArrayList扩容问题实例详解

    本文研究的主要是Java ArrayList扩容问题实例详解的相关内容,具体介绍如下. 首先我们需要知道ArrayList里面的实质的其实是一个Object类型的数组,ArrayList的扩容问题其实就是这个Object类型的数组的扩容问题. transient Object[] elementData; 一.创建时,ArrayList的容量分配 创建一个ArrayList有三种情况 1.默认大小创建(默认为0) ArrayList al = new ArrayList(); 创建完成之后,al

  • Java源码解析ArrayList及ConcurrentModificationException

    本文基于jdk1.8来分析ArrayList的源码 首先是主要的成员变量. /** * Default initial capacity. **/ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. **/ private static final Object[] EMPTY_ELEMENTDATA = {}; /** * Shar

  • Java中Arraylist动态扩容方法详解

    前言 本文主要给大家介绍了关于Java中Arraylist动态扩容的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. ArrayList 概述 ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长.ArrayList不是线程安全的,只能用在单线程环境下.实现了Serializable接口,因此它支持序列化,能够通过序列化传输:实现了RandomAccess接口,支持快速随机访问,实际上就是通过下标序号进行快速访问:实现了Cloneable接口,能被克隆.

  • java 集合之实现类ArrayList和LinkedList的方法

    List 的方法列表 方法名 功能说明 ArrayList() 构造方法,用于创建一个空的数组列表 add(E e) 将指定的元素添加到此列表的尾部 get(int index) 返回此列表中指定位置上的元素 size() 返回此列表中的元素数 clear() 移除此列表中的所有元素 isEmpty() 如果此列表中没有元素,则返回true remove(int index) 移除此列表中指定位置上的元素 indextof(Object o) 返回此列表中首次出现的指定元素的索引,或如果此列表不

  • Java ArrayList.add 的实现方法

    ArrayList是平时相当常用的List实现, 其中boolean add(E e) 的实现比较直接: /** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return <tt>true</tt> (as specified by {@link Collection#add}) */ public boole

  • java中申请不定长度数组ArrayList的方法

    如下所示: import java.util.ArrayList; //java中申请不定长度数组 public class Test01 { public static void main(String[] args) { // TODO Auto-generated method stub ArrayList list=new ArrayList(); list.add("123"); list.add("5"); list.add("5")

  • 对Java ArrayList的自动扩容机制示例讲解

    注意: 不同的JDK版本的扩容机制可能有差异 实验环境:JDK1.8 扩容机制: 当向ArrayList中添加元素的时候,ArrayList如果要满足新元素的存储超过ArrayList存储新元素前的存储能力,ArrayList会增强自身的存储能力,已达到存储新元素的要求 ArrayList:本质通过内部维护的数组对象进行数据存储 ①:分析ArrayList的add(E)方法 public boolean add(E e) { ensureCapacityInternal(size + 1); /

  • Java ArrayList add(int index, E element)和set(int index, E element)两个方法的说明

    一般使用List集合,估计都是使用这个ArrayList,一般呢也就是简单遍历数据和存储数据. 很少使用到add(int index, E element)和set(int index, E element)两个方法. 这两个方法,乍一看,就是在指定的位置插入一条数据. 区别: set()是更新,更新指定下标位置的值. add()是添加,区别于一般的add(E e),这个就是有个位置的概念,特殊位置之后的数据,依次往后移动就是了. 然后,看下面代码.来看看陷阱. 就算是,你知道了上面的内容,也不

  • Java中ArrayList的removeAll方法详解

    本文介绍的是关于Java中ArrayList的removeAll方法的相关内容,分享出来供大家参考学习,下面来一起看看详细的介绍: 在开发过程中,遇到一个情况,就是从所有骑手Id中过滤没有标签的骑手Id(直接查询没有标签的骑手不容易实现), List<Integer> allRiderIdList = new ArrayList(); // 所有的骑手,大致有23W数据 List<Integer> hasAnyTagRiderId = new ArrayList(); // 有标签

  • Java针对ArrayList自定义排序的2种实现方法

    本文实例讲述了Java针对ArrayList自定义排序的2种实现方法.分享给大家供大家参考,具体如下: Java中实现对list的自定义排序主要通过两种方式 1)让需要进行排序的对象的类实现Comparable接口,重写compareTo(T o)方法,在其中定义排序规则,那么就可以直接调用Collections.sort()来排序对象数组 public class Student implements Comparable{ private int id; private int age; p

随机推荐