Java迭代器原理

1迭代器模式

迭代器是一种设计模式，这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

一般实现方式如下：（来自）

aaarticlea/jpeg;base64,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" alt="" />

public interface Iterator {
   public boolean hasNext();
   public Object next();
}

public interface Container {
   public Iterator getIterator();
}

public class NameRepository implements Container {
   public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};

   @Override
   public Iterator getIterator() {
      return new NameIterator();
   }

   private class NameIterator implements Iterator {

      int index;

      @Override
      public boolean hasNext() {
         if(index < names.length){
            return true;
         }
         return false;
      }

      @Override
      public Object next() {
         if(this.hasNext()){
            return names[index++];
         }
         return null;
      }
   }
}

public class IteratorPatternDemo {

   public static void main(String[] args) {
      NameRepository namesRepository = new NameRepository();

      for(Iterator iter = namesRepository.getIterator(); iter.hasNext();){
         String name = (String)iter.next();
         System.out.println("Name : " + name);
      }
   }
}

一般情况，我们自己开发时很少自定义迭代器，因为java本身已经把迭代器做到内部中了

2Java中的迭代器

（1）Iterator接口

package java.util;

import java.util.function.Consumer;

public interface Iterator<E> {

    /**
     * 如果迭代器又更多的元素，返回true。
     * 换句话说，如果next方法返回一个元素而不是抛出一个异常，则返回true。
     */
    boolean hasNext();

    //返回迭代器中的下一个元素，如果没有，则抛出NoSuchElementException异常
    E next();

    /**
     * 从底层集合中删除该迭代器返回的最后一个元素（可选操作）。每执行一次next方法这个方法只能被调用1次。
     * 如果在迭代过程中，除了调用此方法之外，任何其他方法修改基础集合，则迭代器的行为是不确定的。
     * 默认实现是抛出一个UnsupportedOperationException异常，不执行其他操作。
     * 如果每次调用该方法前next方法没有执行，则抛出IllegalStateException异常。
     */
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     * @since 1.8（函数编程）。
     * 对每个剩余元素执行给定的操作，直到所有元素都被处理或动作抛出异常为止。
     * 如果指定了该顺序，则按迭代顺序执行操作。动作抛出的异常被传递给调用者。
     * 如果action为null，则抛出NullPointerException
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

首先，Iterator接口是属于java.util包的。然后里面只有4个方法（用法介绍请看注释）。

forEachRemaining方法是Java8函数编程新加入的。作用是对前游标之后的每个元素进行处理（没有返回值），具体怎么处理根据传入的函数。这项里操作使得迭代器更加灵活，操作粒度更加细致。

补充：default关键字可以让接口中的方法可以有默认的函数体，当一个类实现这个接口时，可以不用去实现这个方法，当然，这个类若实现这个方法，就等于子类覆盖了这个方法，最终运行结果符合Java多态特性。（Java8的新特性）

类注释：

/**
 * An iterator over a collection.  {@code Iterator} takes the place of {@link Enumeration} in the Java Collections Framework.  Iterators
 * differ from enumerations in two ways:
 *
 * <ul>
 *      <li> Iterators allow the caller to remove elements from the underlying collection during the iteration with well-defined semantics.
 *      <li> Method names have been improved.
 * </ul>
 *
 * <p>This interface is a member of the <a href="{@docRoot}/../technotes/guides/collections/index.html">Java Collections Framework</a>.
 */

Iterator是集合上的迭代器。在Java集合框架中Iterator用来替代Enumeration，Iterator与Enumeration有以下两点区别：

• Iterator允许调用者通过定于语义良好的迭代器删除底层集合中的元素。
• 方法名称已得到改进。

这个接口是Java集合框架的成员。除了如上两点不同外，Java8版本Iterator还加入了函数式编程。

（2）Iterable接口

package java.lang;

// 实现此接口，允许对象成为“for-each loop”语句的目标。
public interface Iterable<T> {
    
    // 返回类型为 T元素的迭代器。
    Iterator<T> iterator();

    /**
     * @since 1.8
     * 对Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。 
     * 除非实现类另有规定，否则按照迭代的顺序执行操作（如果指定了迭代顺序）。 动作抛出的异常被转发给调用者。
     * 抛出NullPointerException - 如果指定的动作为空
     */
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    /**
     * @since 1.8
     * 在Iterable描述的元素上创建一个Spliterator。Spliterator继承了迭代器的fail-fast属性。
     *
     */
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

Java集合包最常用的有Collection和Map两个接口的实现类。Map的实现类迭代器是内部实现的，而Collection继承了Iterable接口。

这里以ArrayList为例，梳理一下Iterator的工作流程。

ArrayList是Collection的子类，而Collection又实现了Iterable接口，Iterable接口里面有iterator()方法（该方法返回一个迭代器对象）。所以，ArrayList（或其父类）也必须实现iterator()方法。

iterator()方法返回一个Iterator对象，而前文中Iterator是个接口。我们不能不知道具体用哪个实现类也不能直接new接口，所以我们找到其直接父类AbstractList，查看iterator()到底如何实现的：

 public Iterator<E> iterator() {
        return new Itr();
    }

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

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

这里是通过内部类实现了Iterator接口，然后再将其实例对象返回。

原理很简单，每调用一次next方法，先返回当前游标指向位置的值，然后游标往下移动一位，直到游标数值等于list的size。

而在ArrayList类里面又提供了一个实现版本：

    /**
     * An optimized version of AbstractList.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() {}

        public boolean hasNext() {
            return cursor != 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);
                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();
        }

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

next方法很好理解，和父类大概是一个意思。remove方法是调用ArrayList.this.remove(lastRet)实现：

public E remove(int index) {
        rangeCheck(index);

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

numMoved 是计算要移动的元素个数（删除数组的某一位置的值，后面的值要依次往前移）。

cursor = lastRet;

lastRet = -1;

表示删除之后，游标前移1位。为什么这么做？举个例子，数组a = [1，2，3，4]，若cursor = 2，游标指向数字3，则lastRet = 1。当删除a[1]的时候，a = [1，3，4]。3对应的位置变为1了，所以会有cursor = lastRet。

lastRet的值置为-1，这里很好的解释了前面注释中为什么remove方法一定要在next方法之后执行了。