迭代器模式
迭代器模式又叫做游标（Cursor）模式，其作用是提供一种方法访问一个容器元素中的各个对象，而又不暴露该对象的内部细节。
迭代器模式结构
迭代器模式由以下角色组成：
1、迭代器角色
负责定义访问和遍历元素的接口
2、具体迭代器角色
实现迭代器接口，并要记录遍历中的当前位置
3、容器角色
负责提供创建具体迭代器角色的接口
4、具体容器角色
实现创建具体迭代器角色的接口，这个具体迭代器角色与该容器的结构相关
迭代器模式在JDK中的应用及解读
迭代器模式就不自己写例子了，直接使用JDK中的例子。为什么我们要使用迭代器模式，思考一个问题，假如我有一个ArrayList和一个LinkedList：
List<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(1);
arrayList.add(2); List<Integer> linkedList = new LinkedList<Integer>();
linkedList.add(3);
linkedList.add(4);
如何去遍历这两个List相信每个人都很清楚：
System.out.println("ArrayList：");
for (int i = 0; i < arrayList.size(); i++)
System.out.print(arrayList.get(i) + "\t");
System.out.println("\nLinkedList：");
for (int i = 0; i < linkedList.size(); i++)
System.out.print(linkedList.get(i) + "\t");
运行结果为：
ArrayList：
1 2
LinkedList：
3
这是因为恰好，我们知道ArrayList和LinkedList的访问方式，有些喜欢研究的人知道ArrayList和LinkedList的内部结构，但如果现在我给你一个HashSet：
HashSet<Integer> hashSet = new HashSet<Integer>();
hashSet.add(5);
hashSet.add(6);
将如何遍历？可能你还以为可以使用类似List的遍历方式，不过很遗憾，HashSet中根本没有提供get方法。
这时候就轮到迭代器出场了，不管是什么数据结构，不管你听过还是没听过，不管你见过还是没见过，只要它实现了Iterable接口，都可以用类似的方式去遍历，我把ArrayList、LinkedList、HashSet的遍历写在一起：
Iterator<Integer> iter = null;
System.out.println("ArrayList：");
iter = arrayList.iterator();
while (iter.hasNext())
{
System.out.print(iter.next() + "\t");
}
System.out.println("\nLinkedList：");
iter = linkedList.iterator();
while (iter.hasNext())
{
System.out.print(iter.next() + "\t");
}
System.out.println("\nHashSet：");
iter = hashSet.iterator();
while (iter.hasNext())
{
System.out.print(iter.next() + "\t");
}
看一下运行结果：
ArrayList：
1 2
LinkedList：
3 4
HashSet：
5
看到这就遍历出来ArrayList、LinkedList、HashSet了，以后遇到一个集合，只要实现了iterable接口，也都可以类似这么遍历。这就是开头迭代器模式的定义说的，开发者不需要知道集合中如何去遍历的细节，只管用类似的遍历方法就好了。
Iterable接口和Iterator接口
这两个都是迭代相关的接口，可以这么认为，实现了Iterable接口，则表示某个对象是可被迭代的；Iterator接口相当于是一个迭代器，实现了Iterator接口，等于具体定义了这个可被迭代的对象时如何进行迭代的。参看Iterable接口的定义：
public interface Iterable<T> {
/**
* Returns an iterator over a set of elements of type T.
*
* @return an Iterator.
*/
Iterator<T> iterator();
}
这样对象就可以使用这个类的迭代器进行迭代了，一般Iterable和Iterator接口都是结合着一起使用的。为什么一定要实现Iterable接口而不直接实现Iterator接口了呢，这个问题我也是在自己写了ArrayList和LinkedList的实现之后才想明白的，这么做确实有道理：
因为Iterator接口的核心方法next()或者hasNext()都是依赖于迭代器的当前迭代位置的。如果Collection直接实现Iterator接口，势必导致集合对象中包含当前迭代位置的数据，当集合在不同方法间被传递时，由于当前迭代位置不可预置，那么next()方法的结果会变成不可预知的。除非再为Iterator接口添加一个reset()方法，用来重置当前迭代位置。但即使这样，Collection也同时只能存在一个当前迭代位置。而Iterable，每次调用都返回一个从头开始计数的迭代器，多个迭代器时互不干扰。
可能这么解释不是很明白，再解释明白一点，我自己写的一个ArrayList，如果直接实现Iterator接口，那么势必是这么写的：
public class ArrayList<E> implements List<E>, Iterator<E>, RandomAccess, Cloneable, Serializable
{
/**
* 序列化ID
*/
private static final long serialVersionUID = -5786598508477165970L; private int size = 0;
private transient Object[] elementData = null; public E next()
{
...
} public boolean hasNext()
{
...
}
...
}
这么问题就来了，如果一个ArrayList实例被多个地方迭代，next()方法、hasNext()直接操作的是ArrayList中的资源，假如我在ArrayList中定义一个迭代位置的变量，那么对于不同调用处，这个迭代变量是共享的，线程A迭代的时候将迭代变量设置成了第5个位置，这时候切换到了线程B，对于线程B来讲，就从第5个位置开始遍历此ArrayList了，根本不是从0开始，如何正确迭代？
实现Iterable接口返回一个Iterator接口的实例就不一样了，我为自己写的ArrayList定义一个内部类：
public class ArrayListIterator implements Iterator<E>
{
int iteratorPostion = 0; /**
* 判断是否后面还有元素
*/
@Override
public boolean hasNext()
{
if ((iteratorPostion + 1) > size)
return false;
return true;
} /**
* 返回之前一个元素的引用
*/
@Override
public E next()
{
return (E)elementData[iteratorPostion++];
}
...
}
每次都返回一个返回一个ArrayListIterator实例出去：
/**
* 返回一个ArrayList的迭代器，可以通过该迭代器遍历ArrayList中的元素
*/
public Iterator<E> iterator()
{
return new ArrayListIterator();
}
这就保证了，即使是多处同时迭代这个ArrayList，依然每处都是从0开始迭代这个ArrayList实例的。
迭代器模式的优缺点
优点
1、简化了便利方式，对于对象集合的遍历，还是比较麻烦的，对于数组或者有序列表，我们还可以通过下标来获取，但用户需要在对集合很了解的情况下，才能自行遍历对象（有时即使你了解了集合，还未必能直接遍历，比如上面的HashSet就没有提供get方法）。而引入了迭代器方法后，用户用起来就简单地多了
2、可以供多种遍历方式，比如对于有序列表，可以正向遍历也可以倒序遍历，只要迭代器实现得好
3、封装性好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心
缺点
对于比较简单的遍历（数组或者有序列表），使用迭代器方式遍历较为繁琐而且遍历效率不高，使用迭代器的方式比较适合那些底层以链表形式实现的集合