JDK容器类里的迭代器模式学习

迭代器模式又叫游标模式，是提供一种方法用来访问容器内的元素，而不用暴露容器内部的实现。

这样有2个明显的好处：

1 容器内部的结构发生变化时，如果迭代器本身不发生变化，则外面使用迭代器的业务代码不用修改。

2 如果我们需要提供多于一种的迭代方式，则只需增加迭代器，不用修改容器类。

这2点也正好满足设计模式所要求的单一职责条例。

我们这里重点分析下JDK容器类(ArrayList和LinkedList)使用到的迭代器模式。

JDK提供的迭代器接口为：

public interface Iterator<E> {    boolean hasNext();//判断是否还有元素    E next();//返回下一个元素    void remove();//删除元数}

ArrayList是以数组组织的List，其返回Iterator的接口如下：

public Iterator<E> iterator() {        return new Itr();//Itr是ArrayList内部类，其实现代码如下：}//按照Java的语法规则，内部类可以访问主类的属性和方法。private class Itr implements Iterator<E> {        int cursor;//当前元素的索引        int lastRet = -1;//遍历过程中当前元素的前一个元素，-1表示没有这个元素        int expectedModCount = modCount;//迭代器迭代过程中主类的结构(增加和删除元素等)变更次数                //size表示主类里面元素个数,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;//cursor增加1            return (E) elementData[lastRet = i];//返回第cursor+1个元素        }        public void remove() {            if (lastRet < 0)                throw new IllegalStateException();                checkForComodification();//迭代期间主类的结构是否发生变化，如果发生变化，则抛出异常                        try {                ArrayList.this.remove(lastRet);//删除前一个元素                cursor = lastRet;//cursor指向前一个元素                lastRet = -1;//表示目前没有前一个元素                expectedModCount = modCount;//更正变更次数            } catch (IndexOutOfBoundsException ex) {                throw new ConcurrentModificationException();//抛出并发修改异常            }        }        //判断迭代期间主类的结构是否发生变化        final void checkForComodification() {            if (modCount != expectedModCount)                throw new ConcurrentModificationException();        }}

ArrayList还提供了一种双向迭代器，其实现如下：

//提供双向迭代器public ListIterator<E> listIterator(int index) {     if (index < 0 || index > size)//判断下标是否合法            throw new IndexOutOfBoundsException("Index: "+index);     return new ListItr(index);}private class ListItr extends Itr implements ListIterator<E> {        ListItr(int index) {            super();            cursor = index;//当前元素小标        }        //判断是否有前向元素        public boolean hasPrevious() {            return cursor != 0;        }        //返回下一个指标        public int nextIndex() {            return cursor;        }        //返回前一个元素下标        public int previousIndex() {            return cursor - 1;        }        //返回前一个元素        @SuppressWarnings("unchecked")        public E previous() {            checkForComodification();//判断变更次数            int i = cursor - 1;            if (i < 0)                throw new NoSuchElementException();            Object[] elementData = ArrayList.this.elementData;            if (i >= elementData.length)                throw new ConcurrentModificationException();            cursor = i;            return (E) elementData[lastRet = i];        }        //设置元素值        public void set(E e) {            if (lastRet < 0)                throw new IllegalStateException();            checkForComodification();            try {                ArrayList.this.set(lastRet, e);            } catch (IndexOutOfBoundsException ex) {                throw new ConcurrentModificationException();            }        }        //增加元素        public void add(E e) {            checkForComodification();            try {                int i = cursor;                ArrayList.this.add(i, e);                cursor = i + 1;                lastRet = -1;                expectedModCount = modCount;            } catch (IndexOutOfBoundsException ex) {                throw new ConcurrentModificationException();            }        } }

LinkedList的以双向链表作为数据的组织方式，其内部迭代器的实现和ArrayList的类似，只是访问元素要遍历。

从上面的实现可以看出：

1 我们使用的时候，虽然不知道内部是如何存储的，但我们还是很方便的可以操作容器类的元素，如果内部数组组织方式变了，只要提供正确的迭代器，我们程序不需要修改。

2 增加一种新的迭代器也很方便，不需要对容器类进行修改，内部类的方式只是提供了实现方便，迭代器的实现完全可以独立出来。