迭代器模式(Iterator)

情景：乘车买票，不管你是谁！

定义：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

结构图：

interface Iterator {
	boolean hasNext();
	Object next();	
}

interface Aggreagate {
	//创建迭代器
	Iterator createIterator();
}

public class ConcreteIterator implements Iterator{
	private ConcreteAggregate ca; //定义一个具体聚合对象
	private int currentIndex = 0;
	
	public ConcreteIterator(ConcreteAggregate ca) {//初始化将具体的聚合对象传入
		this.ca = ca;
	}
	
	@Override
	public boolean hasNext() {
		if (currentIndex < ca.getList().size()) {
			return true;
		}
		return false;
	}

	@Override
	public Object next() {
		Object o = ca.getList().get(currentIndex);
		currentIndex++;
		return o;
	}
}

public class ConcreteAggregate implements Aggreagate{
	//用list存放聚合对象
	private List<Object> list = new ArrayList<Object>();
	
	public List<Object> getList() {
		return list;
	}

	public void setList(List<Object> list) {
		this.list = list;
	}

	@Override
	public Iterator createIterator() {
		return new ConcreteIterator(this);
	}
}

//反向遍历
public class ConcreteIteratorDesc implements Iterator{
	private ConcreteAggregate ca;
	private int current = 0;
	public ConcreteIteratorDesc(ConcreteAggregate a) {
		this.ca = a;
		current = ca.getList().size() - 1;
	}

	@Override
	public boolean hasNext() {
		if (current >= 0) {
			return true;
		}
		return false;
	}

	@Override
	public Object next() {
		Object o = ca.getList().get(current);
		current--;
		return o;
	}
}

public class Client {
	public static void main(String[] args) {
		ConcreteAggregate a = new ConcreteAggregate();
		a.getList().add("1");
		a.getList().add("2");
		a.getList().add("3");		
		//Iterator iterator = new ConcreteIteratorDesc(a);
		Iterator iterator = new ConcreteIterator(a);
		while (iterator.hasNext()) {
			Object o = iterator.next();
			System.out.println(o + " ");
		}
	}
}

     总的来说，迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样不仅可以做到不暴露集合内部结构，又可以让外部代码透明地访问集合内部的数据。