* 24种设计模式——迭代器模式

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

迭代器是为容器（Collection/List/Set）服务的，提供了遍历窗口的方便性。

尽量不用自己开发迭代器模式，因为Java提供的Iterator应用到各个聚集类（Collection）中，基本满足需要

一、整理项目信息

1. 项目信息接口

public interface IProject {
	//增加项目
	public void add(String name,int num,int count);
	//从老板这里看到的就是项目信息
	public String getProjectInfo();
	//获取一个可以被遍历的对象
	public IProjectIterator iterator();
}

2. 项目信息

public class Project implements IProject{
	//定义一个项目列表，说有的项目都放在这里
	private List<IProject> projectList = new ArrayList<IProject>();
	//项目名称
	private String name = "";
	//项目成员数量
	private int num = 0;
	//项目费用
	private int cost = 0;
	public Project() {
		super();
		// TODO Auto-generated constructor stub
	}
	//定义一个构造函数，把所有老板需要看到的信息存储起来
	public Project(String name, int num, int cost) {
		super();
		this.name = name;
		this.num = num;
		this.cost = cost;
	}
	//增加项目
	public void add(String name, int num, int count) {
		this.projectList.add(new Project(name, num, count));
	}
	//得到项目的信息
	public String getProjectInfo() {
		String info = "";
		//获得项目的名称
		info = info + "项目名称是:" + this.name;
		//获得项目的人数
		info = info + "\t项目人数:" + this.num;
		//项目费用
		info = info + "\t项目费用:" + this.cost;
		return info;
	}
	//产生一个遍历对象
	public IProjectIterator iterator() {
		return new ProjectIterator(projectList);
	}	
}

3. 项目迭代器接口

public interface IProjectIterator extends Iterator{

}

4. 项目迭代器

public class ProjectIterator implements IProjectIterator{
	//所有项目都放在ArrayList中
	private List<IProject> projectList = new ArrayList<IProject>();
	private int currentItem = 0;
	//构造函数传入projectList
	public ProjectIterator(List<IProject> projectList) {
		this.projectList = projectList;
	}
	//判断是否还有元素，必须实现
	public boolean hasNext() {
		//定义一个返回值
		boolean b = true;
		if(this.currentItem>=projectList.size()||this.projectList.get(this.currentItem)==null){
			b = false;
		}
		return b;
	}
	//取得下一个值
	public IProject next() {
		return (IProject)this.projectList.get(this.currentItem++);
	}
	//删除一个对象
	public void remove() {
		//暂时没有用到
	}
}

5. 老板看报表

public class Boss {
	public static void main(String[] args) {
		//定义一个List,存放所有的项目对象
		IProject project = new Project();
		//增加星球大战项目
		project.add("星球大战项目ddd", 10, 100000);
		//增加扭转时空项目
		project.add("扭转时空项目", 100, 10000000);
		//增加超人改造项目
		project.add("超人改造项目", 1000, 1000000000);
		//这边100个项目
		for(int i = 4;i < 104;i++){
			project.add("第"+i+"个项目", i*5, i*1000000);
		}
		//遍历一下ArrayList,把所有的数据都取出
		IProjectIterator projectIterator = project.iterator();
		while(projectIterator.hasNext()){
			Project p = (Project) projectIterator.next();
			System.out.println(p.getProjectInfo());
		}
	}
}

二、迭代器模式的定义

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

迭代器是为容器服务的，提供了遍历窗口的方便性。

  

1. 抽象迭代器

public interface Iterator {
	//遍历到下一个元素
	public Object next();
	//是否已经遍历到尾部
	public boolean hasNext();
	//删除当前指向的元素
	public boolean remove();
}

2. 具体迭代器

public class ConcreteIterator implements Iterator{
	private Vector vector = new Vector();
	//定义当前游标
	public int cursor = 0;
	public ConcreteIterator(Vector vector) {
		this.vector = vector;
	}
	//返回下一个元素
	public Object next() {
		Object result = null;
		if(this.hasNext()){
			result = this.vector.get(cursor);
			cursor++;
		}else{
			result = null;
		}
		return result;
	}
	//判断是否到达尾部
	public boolean hasNext() {
		if(this.cursor==this.vector.size()){
			return false;
		}else{
			return true;
		}
	}
	//删除当前元素
	public boolean remove() {
		this.vector.remove(this.cursor);
		return true;
	}
}

3. 抽象容器

public interface Aggregate {
	//是容器必然有元素的增加
	public void add(Object object);
	//减少元素
	public void remove(Object object);
	//由迭代器来遍历所有的元素
	public Iterator iterator();
}

4. 具体容器

public class ConcreteAggregate implements Aggregate{
	//容纳对象的窗口
	private Vector vector = new Vector();
	//增加一个元素
	public void add(Object object) {
		this.vector.add(object);
	}
	//删除一个元素
	public void remove(Object object) {
		this.remove(object);
	}
	//返回迭代器对象
	public Iterator iterator() {
		return new ConcreteIterator(this.vector);
	}
}

5. 场景类

public class Client {
	public static void main(String[] args) {
		//声明出容器
		Aggregate agg = new ConcreteAggregate();
		//产生对象数据放进去
		agg.add("abc");
		agg.add("aaa");
		agg.add("1234");
		//遍历一个
		Iterator iterator = agg.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
}