设计模式行为型模式
设计模式, 迭代器模式

迭代器模式

从JDK1.2开始增加java.util.Iterator接口， 并逐步把Iterator应用到各个Collection聚集类中，Collection、List、Set、Map 等都包含了迭代器 。正因为把迭代器模式已经融入到基本API中了，再去写迭代器， 就有点多余，所以迭代器模式没落了，基本上没人会单独写一个迭代器。

迭代器模式提供了遍历容器的方便性，容器只要管理增减元素就可以了，需要遍历时交由迭代器进行。

定义

提供一种方法访问一个容器对象中各个元素，而又不暴露该对象的内部细节。

实现

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。

Iterator抽象迭代器，定义访问和遍历聚合元素的接口，通常包含hasNext()、first()、next()等方法 。 

1
2
3
4
5
interface Iterator {
    Object first();
    Object next();
    boolean hasNext();
}

ConcreteIterator具体迭代器，实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ConcreteIterator implements Iterator {
    private List<Object> list = null;
    private int index = -1;
    public ConcreteIterator(List<Object> list) {
        this.list = list;
    }
    public boolean hasNext() {
        if (index < list.size() - 1) {
            return true;
        } else {
            return false;
        }
    }
    public Object first() {
        index = 0;
        Object obj = list.get(index);
        return obj;
    }
    public Object next() {
        Object obj = null;
        if (this.hasNext()) {
            obj = list.get(++index);
        }
        return obj;
    }
}

Aggregate抽象容器，定义存储、添加、删除聚合对象以及创建迭代器对象的接口。

1
2
3
4
5
public interface Aggregate {
    public void add(Object obj);
    public void remove(Object obj);
    public Iterator getIterator();
}

ConcreteAggregate具体容器 ，实现抽象聚合类，返回一个具体迭代器的实例。

1
2
3
4
5
6
7
8
9
10
11
12
public class ConcreteAggregate implements Aggregate {
    private List<Object> list = new ArrayList<Object>();
    public void add(Object obj) {
        list.add(obj);
    }
    public void remove(Object obj) {
        list.remove(obj);
    }
    public Iterator getIterator() {
        return (new ConcreteIterator(list));
    }
}

客户端调用

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args) {
    Aggregate ag = new ConcreteAggregate();
    ag.add("中山大学");
    ag.add("华南理工");
    ag.add("韶关学院");
    Iterator it = ag.getIterator();
    while (it.hasNext()) {
        Object ob = it.next();
        System.out.print(ob.toString() + "\t");
    }
    Object ob = it.first();
    System.out.println("\nFirst：" + ob.toString());
}

优点

  • 访问一个聚合对象的内容而无须暴露它的内部表示
  • 遍历任务交由迭代器完成，这简化了聚合类
  • 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历
  • 增加新的聚合类和迭代器类都很方便，无须修改原有代码
  • 封装性良好，为遍历不同的聚合结构提供一个统一的接口

缺点

  • 增加了类的个数，这在一定程度上增加了系统的复杂性

应用

当需要为聚合对象提供多种遍历方式时；当需要为遍历不同的聚合结构提供一个统一的接口时。当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

迭代器模式常常与组合模式结合起来使用，在对组合模式中的容器构件进行访问时，经常将迭代器潜藏在组合模式的容器构成类中。