AbstractList类_Iterator内部类

1. 源码

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
   /**
     * The number of times this list has been <i>structurally modified</i>.
     * Structural modifications are those that change the size of the
     * list, or otherwise perturb it in such a fashion that iterations in
     * progress may yield incorrect results.
     *
     * <p>This field is used by the iterator and list iterator implementation
     * returned by the {@code iterator} and {@code listIterator} methods.
     * If the value of this field changes unexpectedly, the iterator (or list
     * iterator) will throw a {@code ConcurrentModificationException} in
     * response to the {@code next}, {@code remove}, {@code previous},
     * {@code set} or {@code add} operations.  This provides
     * <i>fail-fast</i> behavior, rather than non-deterministic behavior in
     * the face of concurrent modification during iteration.
     *
     * <p><b>Use of this field by subclasses is optional.</b> If a subclass
     * wishes to provide fail-fast iterators (and list iterators), then it
     * merely has to increment this field in its {@code add(int, E)} and
     * {@code remove(int)} methods (and any other methods that it overrides
     * that result in structural modifications to the list).  A single call to
     * {@code add(int, E)} or {@code remove(int)} must add no more than
     * one to this field, or the iterators (and list iterators) will throw
     * bogus {@code ConcurrentModificationExceptions}.  If an implementation
     * does not wish to provide fail-fast iterators, this field may be
     * ignored.
     */
    protected transient int modCount = 0;
    
    private class Itr implements Iterator<E> {
        /**
         * Index of element to be returned by subsequent call to next.
         */
        int cursor = 0;

        /**
         * Index of element returned by most recent call to next or
         * previous.  Reset to -1 if this element is deleted by a call
         * to remove.
         */
        int lastRet = -1;

        /**
         * The modCount value that the iterator believes that the backing
         * List should have.  If this expectation is violated, the iterator
         * has detected concurrent modification.
         */
        int expectedModCount = modCount;

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

        public E next() {
            checkForComodification();
            try {
                int i = cursor;
                E next = get(i);
                lastRet = i;
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException(e);
            }
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
}

2. 笔记

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

    /**
     * 统计 List 发生“结构修改”的次数。结构修改是指更改 List 大小或其他可能影响当前
     * Iterator 的操作 List 的行为。
     */
    protected transient int modCount = 0;

    private class Itr implements Iterator<E> {
        /**
         * 下一个将要被遍历到的集合元素的索引
         */
        int cursor = 0;

        /**
         * 最后一次调用 next() 方法返回的集合元素的的索引。如果这个集合元素已经通过
         * remove() 方法删除，lastRet 的值将被置为 -1。
         */
        int lastRet = -1;

        /**
         * 假如当前 Iterator 生成以后，除了当前 Iterator ，外界不对底层 List 进行
         * 任何“结构修改”，底层 List 应该具有的“结构修改”次数（生成当前 Iterator 时
         * 已经具有的修改次数 + 当前 Iterator 的修改次数）。
         * <p>
         * 当前 Iterator 在对底层集合进行“结构修改”时，会同时累加 expectedModCount
         * 和 modCount 的值，所以一旦 expectedModCount 和 modCount 的值变得不一致，
         * 说明外界对底层集合进行了“结构修改”，这就存在集合并发访问的问题。
         */
        int expectedModCount = modCount;

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

        public E next() {
            // 1.并发访问校验
            checkForComodification();

            // 2.获取集合元素
            try {
                int i = cursor;
                // 可能越界访问
                E next = get(i);

                // 每调用一次 next() 方法，只允许调用一次 remove() 方法。
                lastRet = i;

                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                /*
                 * 导致越界访问可能有两种原因：
                 *     1.当前 Iterator 确实已经遍历完了底层集合中的所有元素
                 *     2.外界对底层集合进行了“结构修改”
                 */
                checkForComodification();
                throw new NoSuchElementException(e);
            }
        }

        public void remove() {
            // 每调用一次 next() 方法，只允许调用一次 remove() 方法。
            if (lastRet < 0)
                throw new IllegalStateException();

            /*
             * 如果外界对底层集合进行了“结构修改”，此时如果继续执行 remove() 方法，可能无法
             * 达到调用者预期的目标：remove() 方法通过 next() 方法保存的元素索引值来删除集
             * 合中的元素，此时已经无法保证这个索引值还是之前调用 next() 方法返回的集合元素。
             */
            checkForComodification();

            try {
                AbstractList.this.remove(lastRet);

                /*
                 * 删除元素后，底层集合的大小已经发生了改变，因此需要调整 cursor 的值以确保再次
                 * 调用 next() 时能够返回正确的集合元素。
                 */
                if (lastRet < cursor)
                    cursor--;

                // 每调用一次 next() 方法，只允许调用一次 remove() 方法。
                lastRet = -1;

                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
}