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