迭代器模式

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

多个对象聚在一起形成的总体称之为聚集(Aggregate)，聚集对象是能够包容一组对象的容器对象。

一个聚集对象，不管对象 是什么都需要遍历的时候，考虑使用迭代器模式。

迭代器模式(Iterator)结构图

Iterator迭代器抽象类

package iterator;

/**
 * @author ANYO
 * 用来定义得到
 * 开始对象
 * 得到下一个对象
 * 判断是否到结尾
 * 当前对象等抽象方法的统一接口
 */
abstract class Iterator {
	public abstract Object First();
	public abstract Object Next();
	public abstract boolean IsDone();
	public abstract Object CurrentItem();
}

Aggregate聚集抽象类

package iterator;

abstract class Aggregate {
	public abstract Iterator CreateIterator();	//创建迭代器	
}

ConcreteIterator具体迭代器类，继承Iterator

package iterator;

public class ConcreteIterator extends Iterator {
	
	private ConcreteAggregate aggragate;	//定义一个具体聚集对象
	private int current = 0;
	
	/**
	 * 构造函数，初始化时将聚集对象传入
	 * @param aggragate
	 */
	public ConcreteIterator(ConcreteAggregate aggragate) {	
		this.aggragate = aggragate;
	}

	@Override
	public Object First() {		//得到聚集的第一个对象
		// TODO Auto-generated method stub
		return aggragate.getItems(0);
	}

	@Override
	public Object Next() {		//得到聚集的下一个对象
		current++;
		if(current<aggragate.Count()){
			return aggragate.getItems(current);
		}
		return null;
	}

	@Override
	public boolean IsDone() {		//判断遍历是否到结尾
		// TODO Auto-generated method stub
//		System.out.println(current);
		return current>=aggragate.Count()?true:false;
	}

	@Override
	public Object CurrentItem() {	//返回遍历时的当前对象
		// TODO Auto-generated method stub
		return aggragate.getItems(current);
	}

}

ConcreteAggregate具体聚集类，继承Aggregate

package iterator;

import java.util.ArrayList;
import java.util.List;

public class ConcreteAggregate extends Aggregate {
	/**
	 * 声明一个list泛型变量，用于存放聚合对象
	 */
	private List<Object> items = new ArrayList<>();
	
	
	@Override
	public Iterator CreateIterator() {
		// TODO Auto-generated method stub
		return new ConcreteIterator(this);
	}
	
	public int Count(){
		return items.size();	//返回聚集总个数
	}
	
	public Object getItems(int index){
		return items.get(index);
	}
	
	public void addItems(Object item){
		items.add(item);
	}
}

客户端

package iterator;

public class Client {

	public static void main(String[] args) {
		ConcreteAggregate  a = new ConcreteAggregate();
		a.addItems("小鸟");
		a.addItems("小菜");
		a.addItems("行李");
		a.addItems("老外");
		a.addItems("司机");
		a.addItems("售票员");
		
		Iterator iterator = new ConcreteIterator(a);
		int i = 0;
		while(!iterator.IsDone()){
			System.out.println(iterator.CurrentItem()+" 请买票");
				iterator.Next();
		}
	}

}

输出结果

小鸟 请买票
小菜 请买票
行李 请买票
老外 请买票
司机 请买票
售票员 请买票

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