迭代器模式

迭代器模式（Iterator pattern）：提供一种方法访问一个容器对象中的各个元素，而又不需要暴露该对象的内部细节。

类图及定义

迭代器角色（Iterator）：负责定义访问和遍历元素的接口。
具体迭代器角色（concrete iterator）：实现接口，记录遍历中的当前位置。
容器角色（aggregate/container）：负责提供创建具体迭代器角色的接口。
具体容器角色（concrete aggregate/container）：实现创建具体迭代器角色的接口，这个具体迭代器角色和该容器的结构有关。

从结构上讲

1. 迭代器模式在客户和容器之间添加了迭代器角色，很好地避免了容器细节的暴露。
2. 具体迭代角色和具体容器角色是耦合在一起的，遍历算法是与容器的内部细节紧密相关的。
3. 迭代器角色抽象了具体迭代角色，使客户程序更具一般性和重用性，被称为多态迭代（遍历不同的容器结构提供统一的接口）。

迭代器原理

Iterator依赖子类去实现，子类中的方法依赖容器中的内容去实现 Iterator接口，该对象必须依赖于具体容器，因为每个容器的数据结构不同，所 对于容器而言，具体的实现不重要，只要通过容器获取到该实现的迭代器对象即 Iterator接口是所有Iterator容器进行元素抽取出的公共接口。

迭代器的使用（java集合）

客户端先得到具体容器角色，然后通过具体容器角色得到具体迭代器角色。这样便可以使用具体迭代角色来遍历容器了。

Collection coll = new Arraylist();
Iterator it = coll.iterator();
while(it.hasNext()) {
  it.next(); 
}

Demo

//聚集接口
public interface Aggregate<T> {
    public Iterator<T> createIterator();
}
//具体聚集类
public class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> items = new ArrayList<T>();

    @Override
    public Iterator<T> createIterator() {
    	return new ConcreteIterator<T>(this);
    }
    public int count() {
    	return items.size();
    }
    public T getItems(int index) {
    	return items.get(index);
    }
    public void setItems(T item) {
    	items.add(item);
    }
}
//迭代器接口
public interface Iterator<T> {
    public T first();
    public T next();
    public boolean isDone();
    public T currentItem();
}
/**
 * 具体迭代器类，给出一种具体迭代的实现方式。
 * 思考：迭代器表示的是一种迭代的行为，而聚集则是真正要被迭代的数据集合。
 * 之所以要将迭代器和聚集分开，就是为了将行为与数据分开。 可类比Java中Iterator与Iterable的关系进行理解
 */
public class ConcreteIterator<T> implements Iterator<T> {

    private ConcreteAggregate<T> concreteAggregate;
    private int current = 0;

    public ConcreteIterator(ConcreteAggregate<T> concreteAggregate) {
    	this.setConcreteAggregate(concreteAggregate);
    }
    @Override
    public T first() {
    	return concreteAggregate.getItems(0);
    }
    @Override
    public T next() {
    	current++;

    	if (current < concreteAggregate.count()) {
    		return concreteAggregate.getItems(current);
    	}

    	return null;
    }

    @Override
    public boolean isDone() {
    	return current >= concreteAggregate.count() ? true : false;
    }
    @Override
    public T currentItem() {
    	return concreteAggregate.getItems(current);
    }
    public ConcreteAggregate<T> getConcreteAggregate() {
    	return concreteAggregate;
    }
    public void setConcreteAggregate(ConcreteAggregate<T> concreteAggregate) {
    	this.concreteAggregate = concreteAggregate;
    }
    public int getCurrent() {
    	return current;
    }
    public void setCurrent(int current) {
    	this.current = current;
    }

}
//客户端
public class Client {
    public static void main(String[] args) {
		ConcreteAggregate<String> bus = new ConcreteAggregate<String>();
	
		bus.setItems("大鸟");
		bus.setItems("小菜");
		bus.setItems("行李");
		bus.setItems("老外");
		bus.setItems("公交内部员工");
		bus.setItems("小偷");
	
		Iterator<String> iterator = new ConcreteIterator<String>(bus);
	
		while (!iterator.isDone()) {
		    System.out.println(iterator.currentItem() + "请买票！");
		    iterator.next();
		}
    }

}

上一篇: 装饰者模式
下一篇: 访问者模式