一、 引言
迭代这个名词对于熟悉Java的人来说绝对不陌生。我们常常使用JDK提供的迭代接口进行java collection的遍历：
| Iterator it = list.iterator(); while(it.hasNext()){ //using “it.next();”do some businesss logic } |
而这就是关于迭代器模式应用很好的例子。
二、 定义与结构
迭代器（Iterator）模式，又叫做游标（Cursor）模式。GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。
从定义可见，迭代器模式是为容器而生。很明显，对容器对象的访问必然涉及到遍历算法。你可以一股脑的将遍历方法塞到容器对象中去；或者根本不去提供什么遍历算法，让使用容器的人自己去实现去吧。这两种情况好像都能够解决问题。
然而在前一种情况，容器承受了过多的功能，它不仅要负责自己“容器”内的元素维护（添加、删除等等），而且还要提供遍历自身的接口；而且由于遍历状态保存的问题，不能对同一个容器对象同时进行多个遍历。第二种方式倒是省事，却又将容器的内部细节暴露无遗。
而迭代器模式的出现，很好的解决了上面两种情况的弊端。先来看下迭代器模式的真面目吧。
迭代器模式由以下角色组成：
1) 迭代器角色（Iterator）：迭代器角色负责定义访问和遍历元素的接口。
2) 具体迭代器角色（Concrete Iterator）：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。
3) 容器角色（Container）：容器角色负责提供创建具体迭代器角色的接口。
4) 具体容器角色（Concrete Container）：具体容器角色实现创建具体迭代器角色的接口——这个具体迭代器角色于该容器的结构相关。
迭代器模式的类图如下：
 |
从结构上可以看出，迭代器模式在客户与容器之间加入了迭代器角色。迭代器角色的加入，就可以很好的避免容器内部细节的暴露，而且也使得设计符号“单一职责原则”。
注意，在迭代器模式中，具体迭代器角色和具体容器角色是耦合在一起的——遍历算法是与容器的内部细节紧密相关的。为了使客户程序从与具体迭代器角色耦合的困境中脱离出来，避免具体迭代器角色的更换给客户程序带来的修改，迭代器模式抽象了具体迭代器角色，使得客户程序更具一般性和重用性。这被称为多态迭代。
三、 举例
由于迭代器模式本身的规定比较松散，所以具体实现也就五花八门。我们在此仅举一例，根本不能将实现方式一一呈现。因此在举例前，我们先来列举下迭代器模式的实现方式。
1．迭代器角色定义了遍历的接口，但是没有规定由谁来控制迭代。在Java collection的应用中，是由客户程序来控制遍历的进程，被称为外部迭代器；还有一种实现方式便是由迭代器自身来控制迭代，被称为内部迭代器。外部迭代器要比内部迭代器灵活、强大，而且内部迭代器在java语言环境中，可用性很弱。
2．在迭代器模式中没有规定谁来实现遍历算法。好像理所当然的要在迭代器角色中实现。因为既便于一个容器上使用不同的遍历算法，也便于将一种遍历算法应用于不同的容器。但是这样就破坏掉了容器的封装——容器角色就要公开自己的私有属性，在java中便意味着向其他类公开了自己的私有属性。
那我们把它放到容器角色里来实现好了。这样迭代器角色就被架空为仅仅存放一个遍历当前位置的功能。但是遍历算法便和特定的容器紧紧绑在一起了。
而在Java Collection的应用中，提供的具体迭代器角色是定义在容器角色中的内部类。这样便保护了容器的封装。但是同时容器也提供了遍历算法接口，你可以扩展自己的迭代器。
好了，我们来看下Java Collection中的迭代器是怎么实现的吧。
| //迭代器角色，仅仅定义了遍历接口 public interface Iterator { boolean hasNext(); Object next(); void remove(); } //容器角色，这里以List为例。它也仅仅是一个接口，就不罗列出来了 //具体容器角色，便是实现了List接口的ArrayList等类。为了突出重点这里指罗列和迭代器相关的内容 //具体迭代器角色，它是以内部类的形式出来的。AbstractList是为了将各个具体容器角色的公共部分提取出来而存在的。 public abstract class AbstractList extends AbstractCollection implements List { …… //这个便是负责创建具体迭代器角色的工厂方法 public Iterator iterator() { return new Itr(); } //作为内部类的具体迭代器角色 private class Itr implements Iterator { int cursor = 0; int lastRet = -1; int expectedModCount = modCount; public boolean hasNext() { return cursor != size(); } public Object next() { checkForComodification(); try { Object next = get(cursor); lastRet = cursor++; return next; } catch(IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } } public void remove() { if (lastRet == -1) 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(); } } |
再举一个内部迭代器例子：
- /**
- * 聚集抽象类
- */
- public abstract class Aggregate {
- // 创建迭代器
- public abstract Iterator createIteraotr();
- }
- /**
- * 具体的聚集类，继承聚集抽象类Aggregate
- */
- public class ConcreteAggregate extends Aggregate{
- // 声明一个List泛型变量，用于存放聚合对象
- private List<Object> items = new ArrayList<Object>();
- @Override
- public Iterator createIteraotr() {
- return new ConcreteIterator(this);
- }
- // 返回集合总个数
- public int count(){
- return items.size();
- }
- public List<Object> getItems() {
- return items;
- }
- public void setItems(List<Object> items) {
- this.items = items;
- }
- }
- /**
- * 迭代器抽象类
- */
- public abstract class Iterator {
- // 开始对象
- public abstract Object first();
- // 下一个对象
- public abstract Object next();
- // 当前对象
- public abstract Object currentItem();
- // 是否到结尾
- public abstract boolean isDone();
- }
- /**
- * 具体的迭代器类，继承迭代器抽象类Iterator
- */
- public class ConcreteIterator extends Iterator{
- // 定义一个具体的聚集对象
- private ConcreteAggregate aggregate;
- private int current =0 ;
- // 初始化时将具体的聚集对象传入
- public ConcreteIterator(ConcreteAggregate aggregate){
- this.aggregate =aggregate;
- }
- @Override
- public Object currentItem() {
- // 返回当前的聚集对象
- return aggregate.getItems().get(current);
- }
- @Override
- public Object first() {
- // 得到聚集的第一个对象
- return aggregate.getItems().get(0);
- }
- @Override
- public boolean isDone() {
- // 判断当前是否遍历到结尾，到结尾返回true
- return current>=aggregate.count()?true:false;
- }
- @Override
- public Object next() {
- // 得到聚集的下一个对象
- Object ref = null;
- current++;
- if(current<aggregate.count()){
- ref = aggregate.getItems().get(current);
- }
- return ref;
- }
- }
- /**
- * 反向遍历的具体的迭代器类，继承迭代器抽象类Iterator
- */
- public class ConcreteIteratorDesc extends Iterator{
- // 定义一个具体的聚集对象
- private ConcreteAggregate aggregate;
- private int current =0 ;
- // 初始化时将具体的聚集对象传入
- public ConcreteIteratorDesc(ConcreteAggregate aggregate){
- this.aggregate =aggregate;
- current = aggregate.count()-1;
- }
- @Override
- public Object currentItem() {
- // 返回当前的聚集对象
- return aggregate.getItems().get(current);
- }
- @Override
- public Object first() {
- // 得到聚集的第一个对象
- return aggregate.getItems().get(aggregate.count()-1);
- }
- @Override
- public boolean isDone() {
- // 判断当前是否遍历到结尾，到结尾返回true
- return current<0?true:false;
- }
- @Override
- public Object next() {
- // 得到聚集的下一个对象
- Object ref = null;
- current--;
- if(current>=0){
- ref = aggregate.getItems().get(current);
- }
- return ref;
- }
- }
- public class Main {
- public static void main(String[] args) {
- // 聚集对象（公交车）
- ConcreteAggregate a = new ConcreteAggregate();
- // 对象集合（新上来的乘客)
- List<Object> items = new ArrayList<Object>();
- items.add("大鸟");
- items.add("小菜");
- items.add("行李");
- items.add("老外");
- items.add("公交内部员工");
- items.add("小偷");
- a.setItems(items);
- // 迭代器对象
- Iterator i = new ConcreteIterator(a);
- // 迭代器第一个对象（从第一个乘客开始)
- Object item = i.first();
- while(!i.isDone()){
- System.out.println(i.currentItem()+"请买车票");
- i.next();
- }
- System.out.println("------------反向遍历---------------");
- //-----反向遍历-------------------
- Iterator iDesc = new ConcreteIteratorDesc(a);
- // 迭代器第一个对象（从最后一个乘客开始)
- Object item2 = iDesc.first();
- while(!iDesc.isDone()){
- System.out.println(iDesc.currentItem()+"请买车票");
- iDesc.next();
- }
- }
- }
输出结果如下：
- 大鸟请买车票
- 小菜请买车票
- 行李请买车票
- 老外请买车票
- 公交内部员工请买车票
- 小偷请买车票
- ------------反向遍历---------------
- 小偷请买车票
- 公交内部员工请买车票
- 老外请买车票
- 行李请买车票
- 小菜请买车票
- 大鸟请买车票
至于迭代器模式的使用。正如引言中所列那样，客户程序要先得到具体容器角色，然后再通过具体容器角色得到具体迭代器角色。这样便可以使用具体迭代器角色来遍历容器了……
四、 实现自己的迭代器
在实现自己的迭代器的时候，一般要操作的容器有支持的接口才可以。而且我们还要注意以下问题：
在迭代器遍历的过程中，通过该迭代器进行容器元素的增减操作是否安全呢？
在容器中存在复合对象的情况，迭代器怎样才能支持深层遍历和多种遍历呢？
以上两个问题对于不同结构的容器角色，各不相同，值得考虑。
五、 适用情况
由上面的讲述，我们可以看出迭代器模式给容器的应用带来以下好处：
1) 支持以不同的方式遍历一个容器角色。根据实现方式的不同，效果上会有差别。
2) 简化了容器的接口。但是在java Collection中为了提高可扩展性，容器还是提供了遍历的接口。
3) 对同一个容器对象，可以同时进行多个遍历。因为遍历状态是保存在每一个迭代器对象中的。
由此也能得出迭代器模式的适用范围：
1) 访问一个容器对象的内容而无需暴露它的内部表示。
2) 支持对容器对象的多种遍历。
3) 为遍历不同的容器结构提供一个统一的接口（多态迭代）。
六、 总结
迭代器模式在我们的应用中很广泛，希望本文能帮助你理解它。如有不对之处，还请不吝指正。
扫一扫
1034
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
