分析ArrayList在遍历时修改报错的原因

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u012987546/article/details/52190851

以前使用for(:){}遍历List集合并同时修改List集合中的内容时会报:ConcurrentModificationException错误,这个错误就是提示我们:方法中有对象的并发修改,但不允许这种修改时,所以抛出此异常。

1.模拟遍历集合的同时修改集合(一)

新建一个list集合,并给该集合依次添加1-5的字符窜,然后遍历集合,在遍历集合的时候删除”2”

        public static void main(String[] args) {
             List<String> list = new ArrayList<String>();
                list.add("1");
                list.add("2");
                list.add("3");
                list.add("4");
                list.add("5");
                System.out.println("原来的list:" + list);
                for (String string : list) {
                    System.out.println(string);
                    //如果获取的内容是"2",就把它删除
                    if ("2".equals(string)) {
                        list.remove(string);
                    }
                }
                System.out.println("修改后的list:: " + list);
        }

输出的结果:

    原来的list:[1, 2, 3, 4, 5]
    1
    2
    Exception in thread "main" java.util.ConcurrentModificationException
        at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
        at java.util.ArrayList$Itr.next(Unknown Source)
        at com.test.jh.TestListDemo.main(TestListDemo.java:16)

当集合遍历到”2”这个元素的时候,就出现了ConcurrentModificationException异常,拿到底是哪一个方法抛出的异常?其实是Iterator类中next()的方法抛出的异常。

2.foreach遍历集合的原理分析

通过反编译技术,反编译上面mian方法中的代码

    public static void main(String args[])
    {
        List list = new ArrayList();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        //1.字符串通过+拼接的底层实现也是通过StringBuilder这个类
        System.out.println((new StringBuilder("原来的list:")).append(list).toString());
        //2.使用for (String string : list) 遍历集合的底层是使用Iterators实现
        for (Iterator iterator = list.iterator(); iterator.hasNext();)
        {
            //3.重点:这里调用了next()方法,其实上面的那个错误就是调用了这个方法报错的
            String string = (String)iterator.next();
            System.out.println(string);
            if ("2".equals(string))
                list.remove(string);
        }

        System.out.println((new StringBuilder("修改后的list:: ")).append(list).toString());
    }

同过分析foreach遍历集合的原理,遍历集合的底层是使用Iterators实现,并且报错是因为执行了String string = (String)iterator.next();这一行代码

3.ArrayList的源码分析

查看Iterator中的next()方法

因为报错的原因是执行了:String string = (String)iterator.next();这句,那查看Iterator类的代码

        //把集合修改的次数(modCount)赋值给expectedModCount记录下来
        int expectedModCount = modCount;    

        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() {
            //modCount代表集合修改的次数(例如:每list.add()一次就加1,list.remove()一次也加1)
            //expectedModCount的值是等于开始遍历集合时的修改的次数
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

checkForComodification()方法中的modCount与expectedModCount的值不相等就会抛出异常。那么他们两个值分别在哪里被修改了呢?其实modCount的值是在list集合执行add,remove等操作的时候赋值,而expectedModCount是在new Iterator()时,把modCount的值赋给了expectedModCount记录。

查看ArrayList类的源码

那查看ArrayList类的remove()代码,发现remove方法中真的有对modCount++

    public E remove(int index) {
        rangeCheck(index);
        //记录了集合修改的次数,其实集合中的add()方法中也有modCount++;的代码
        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

聪明的你,从上面的代码就可以知道,当我们遍历集合的并修改集合的内容时,为什么会导致checkForComodification()中的值不相等就会抛出ConcurrentModificationException异常。

4.遍历List集合并同时修改List集合中的内容报错的原因

    public static void main(String args[])
    {
        List list = new ArrayList();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");

        System.out.println((new StringBuilder("原来的list:")).append(list).toString());
        //3.重点:list.iterator()
        for (Iterator iterator = list.iterator(); iterator.hasNext();)
        {
            String string = (String)iterator.next();
            System.out.println(string);
            if ("2".equals(string))
                list.remove(string);
        }

        System.out.println((new StringBuilder("修改后的list:: ")).append(list).toString());
    }

1.当代码在遍历的时候执行到list.iterator()时候就创建了一个Iterator对象,并在创建这个Iterator对象的时候modCount的值赋值给了expectedModCount,这时expectedModCount的值就是集合当前修改的次数。

     //执行list.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
        //创建这个Iterator对象的时候modCount的值赋值给了expectedModCount,这时expectedModCount的值就是集合当前修改的次数
        int expectedModCount = modCount;

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

        .....
    }

2.当代码在执行到下面的这个语句的时候,执行了list.remove(),这个时候modCount++;导致了modCount与expectedModCount不相等。那些下一次的循环在调用String string = (String)iterator.next();的时候就会导致next()方法中的checkForComodification()方法中的modCount与expectedModCount的值不相等就会抛出异常ConcurrentModificationException。

    if ("2".equals(string))
                list.remove(string);

  • 总结

    其实出现异常就是我们在遍历集合的时候修改了集合的内容,导致modCount的值在增加,而expectedModCount得值没有增加,所以在调用next()方法中的checkForComodification()方法判断集合的修改次数是否合法就会报错。

6.模拟遍历集合的同时修改集合(二)

新建一个list集合,并给该集合依次添加1-5的字符窜,然后遍历集合,在遍历集合的时候删除”4”(倒数第二个)

        public static void main(String[] args) {
             List<String> list = new ArrayList<String>();
                list.add("1");
                list.add("2");
                list.add("3");
                list.add("4");
                list.add("5");
                System.out.println("原来的list:" + list);
                for (String string : list) {
                    System.out.println(string);
                    //重点:是删除"4",而不是"2",那么会报错吗?其实不会
                    if ("4".equals(string)) {
                        list.remove(string);
                    }
                }
                System.out.println("修改后的list:: " + list);
        }

输出的结果是:

    原来的list:[1, 2, 3, 4, 5]
    1
    2
    3
    4
    修改后的list:: [1, 2, 3, 5]

从上面的可以看出,靠,居然没有报错成功删除了?这是什么情况?

分析原因

1.当执行到下面的代码的时候,list.remove()删除了一个元素,导致size也减少了1。

    //当前的cursor=4,size=5
    if ("4".equals(string)) {
         list.remove(string);//删除了一个size-1等于4
    }

2.接着当增强for循环再次判断hasNext():

    public boolean hasNext() {
            //当遍历到"4"的时候,当前的cursor=4,当前的size=4
            return cursor != size;
    }

3.当执行到for (Iterator iterator = list.iterator(); iterator.hasNext();)的iterator.hasNext()时,返回的值是false。为什么呢?当遍历到”4”的时候,当前的cursor=4,size=4,导致hasNext()返回的值是false导致直接退出了for循环,漏掉了第五次循环(第五次也是最后一个循环),导致没有执行String string = (String)iterator.next();就没有报错。

4.如果我们删除的那个不是”4”,而是”3”,结果导致当前的cursor=3,当前的size=4,当下一次执行iterator.hasNext()判断时,返回的结果是true,导致String string = (String)iterator.next();会执行,删除一个元素后,导致modCount的值在增加,而expectedModCount得值没有增加,所以在调用next()方法中的checkForComodification()方法判断集合的修改次数是否合法就会报错。

展开阅读全文

没有更多推荐了,返回首页