ArrayList迭代器学习

ArrayList迭代器学习 迭代器的了解

迭代器的作用是用来访问容器（用来保存元素的数据结构）中的元素，所以使用迭代器，我们就可以访问容器中里面的元素。

指针通常用来访问的是序列的元素，但不是所有的容器都会在连续的内存空间上保存数据。而且每一种容器，都会有专门配对的迭代器。

下面是ArrayList迭代器的源码以及个人的解析

 private class Itr implements Iterator<E> {
     /*
     作为ArrayList的一个内部类，并且实现了Iterator接口
    Iterator接口有如下方法
    boolean hasNext();
   	E next();
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
    上述方法都在Itr中进行了实现与重写
    返回的便是由该类生成的对象
     */
        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;
        }
//通过判断curso的值和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);//调用ArrayList的remove方法
            	cursor = lastRet;//将上一次索引赋值给下一次索引，即cursor位置前移
           		lastRet = -1;//重置lastRet
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            //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();
        }
     /*checkForComodification方法，其实是用来检查在迭代过程中有无被修改，
     如果被修改的话抛出ConcurrentModificationException异常，避免了混乱。
     */
    }