迭代器模式

迭代器模式：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示.

 1.当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历时,就应该考虑用迭代器模式。
 2.当需要对聚集对象有多种遍历方式时，可以考虑用迭代器模式。
 3.迭代器模式在访问数组，集合，列表等数据时，尤其是数据库数据操作时，是非常普遍的应用，

    所以各种高级语言 都对它进行了封装，反而给人感觉此模式本身不太常用。

 

 

/**
 * 聚集抽象类
 */
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();
		}
	}
}

 

输出结果如下：

 

大鸟请买车票
小菜请买车票
行李请买车票
老外请买车票
公交内部员工请买车票
小偷请买车票
------------反向遍历---------------
小偷请买车票
公交内部员工请买车票
老外请买车票
行李请买车票
小菜请买车票
大鸟请买车票