Java集合迭代器 Iterator

Iterator是个接口，是对Collection进行迭代的迭代器，遍历Collection里面的元素

Iterator的用法

Iterator共有三种用法：

boolean hasnext( ) 、、是否还有下个节点

E next( )、、指向下个节点

void remove( )、、移除迭代器元素

遍历Collection的时候，用hasnext( )去判断，是否还有下一个元素，如果有的话继续遍历，如果没有的话跳出循环

@Test //测试标签
    public void test1(){
        List list = Lists.newArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        for (Iterator iterator = list.iterator();iterator.hasNext();){
            System.out.println(iterator.next());
        }
        /*
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }*/
    }

Iterator原理

Iterator是个接口，接口作用在于扩展功能，其中的方法只有特征，没有方法的实现

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

进一步看源码可知，Collection的子类ArrayList中就使用了这个接口的三个方法，如下：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final Object[] EMPTY_ELEMENTDATA = {};
    private transient Object[] elementData;
    private int size;// ArrayList中元素的个数

    // 常见的构造方法，由这里可知，ArrayList的底层是数组
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    // ArrayList类中的iterator（）方法，
    //返回的是一个实现了Iterator接口的具体类的对象
    public Iterator iterator() {
            return new Itr();
    }

    // Itr实现了Iterator接口，并且是ArrayList的内部类
    private class Itr implements Iterator<E> {
        //游标：要返回元素的索引
        int cursor;     
        // 上一个返回元素的索引，如果上次没有返回，为-1  
        int lastRet = -1; 
        int expectedModCount = modCount;

    /**
     * hasNext()方法：判斷游标是否等于底层数组长度。
     * 等于说明遍历已到达数组最后，无元素可供遍历；
     * 否则继续遍历。
     */
        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中的remove（int index）方法
                ArrayList.this.remove(lastRet);
                //游标改为上次返回元素的索引
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }   
    }   
}

由上面的源码可知，Iterator中的方法在ArrayList中的实现依赖于ArrayList底层的数据结构。同样地，这三个方法在Collection其他子类中的实现也都依赖于子类不同的结构，所以具体的实现也不完全相同。这也是Iterator为什么要定义成一个接口的原因。（Collection子类底层的结构不一样，对不同的collection遍历，采用的方式也就不一样，所以每个collection都有自己独特的遍历方式。因此Iterator就不可能对各自不同的遍历作出统一的实现，而是让collection本身实现元素的遍历。这样Iterator就不能定义为类了，而只能是接口。）