ArrayList源码你真的理解了吗

问题

相信不少小伙伴，在面试的时候被问过jdk中相关源码的部分， 最近就被问道了关于ArrayList的源码， 上来就是问有没有看过ArrayList的源码，怎么在遍历中移除ArrayList中的元素？ ，普通的循环会抛出何种异常，为啥迭代器的方式不会报异常，

答案：

• 普通的for循环编译其实会调用Itr的next去获取元素， 会抛出ConCurrentModificationException.

• 方式有两种:

• 方式一： 通过迭代器的方式，ArrayList 内部有一个实现了Itereator 接口的内部类 Itr ，可以通过Itr的对象的remove方法移除元素

• 方式二： Collection 接的removeIf方法 移除元素

分析

通过编译以后的文件可以看出 其实for循环的时候是调用了List.iterator方法

/** 通过源码可以看到 iterator方法放回的是一个Itr对象
 *Itr对象是ArrayList中实现了Iteartor接口的内部类
 */ ArrayList.iterator 
public Iterator<E> iterator() {
    return new Itr();
}
	

私有内部类Itr源码，三个重要成员变量，
cusor: 下一元素索引开始默认为0
lasRet: 最后一个元素的索引位置
expectedModCount ：创建迭代器时，集合的修改的次数
正是因为普通的for循环实际是调用的ArrayList的内置对象Itr 去遍历数据，而Itr的next方法设置了修改校验，当在for循环中调用remove方法的时候使得实际修改次数与实际的修改次数不一致，从而判定了，循环时发生了并发修改抛出异常。

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
        //预期的修改次数，即创建迭代器时候的数组修改次数。
        //modcount表示的是实际的修改次数,每一次修改或者新增的时候都会对该值加一
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }
        @SuppressWarnings("unchecked")
        public E next() {
            //检查是否发生修改 ----*****重点******
            checkForComodification();
            //判断下一个位位置的所有是否超过size
            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();
        }
        /**
        *如果有修改则直接 抛出CurrentModifaidException ------>快速失败机制（fail-fast）
        *比较预期修改次数与实际修改次数，不相等则说明被修改过了，直接抛出异常
        *
        */
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

2.怎么才能在循环中向List中移除或者添加数据呢？

方式一：迭代器
与for循环最大的不同就是，调用iterator接口的remove方法，也就是ArrayList中内置对象Itr中的remove方法，查看源码可以其中奥妙的地方在于，这个remove方法居然不会使得modCunt++,
并且还强制将modCount的值赋值给了expectedpmodCount. 这样一来就是使得modCount永远与expectedmodeCount想等从而 checkForComodification不会报异常
测试代码：

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
    String next = iterator.next();
    if (next.equals("b")){
        iterator.remove();
    }
}
System.out.println(list.toString());

iterator.remove() 源码：

/**
* 与ArrayList.remove()方法最大的不同就是移除元素后的时候modCount并未加一
*这是也关键所在
*/
public void remove() {
    if (lastRet < 0)
        throw new IllegalStateException();
        //因为此时还未修改，expectedModCount==modCount 所以此处不会抛出异常
    checkForComodification();

    try {
        //移除元素当前位置的元素
            ArrayList.this.re move(lastRet);
        cursor = lastRet;
        lastRet = -1;
        //强制相等
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

方式二： removeIf
因为ArraryList实现了间接实现了Collection接口也可以使用Colletion.的removeIf 方法，其如果搞清楚了Iteartor的remove()方法为什么不报错，这个一看源码便是一清二楚。

测试代码：

list.removeIf(fiter->fiter.equals("b"));

源码：（一看便知，换汤不换药，还是Iteator.remove()）

default boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    boolean removed = false;
    final Iterator<E> each = iterator();
    while (each.hasNext()) {
        if (filter.test(each.next())) {
            each.remove();
            removed = true;
        }
    }
    return removed;
}