迭代器模式

一、定义

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

 

二、迭代器模式结构图

迭代器模式中的角色：

（1）迭代器角色(Iterator)：定义遍历元素所需要的方法。

（2）具体迭代器角色(Concrete Iterator)：实现迭代器接口中定义的方法，完成集合的迭代。

（3）容器角色(Aggregate)：一般是一个接口，提供一个iterator()方法。

（4）具体容器角色(ConcreteAggregate)：就是抽象容器的具体实现类。

 

三、示例

Iterator迭代器抽象类 

public abstract class Iterator {
	public abstract Object First();
	public abstract Object Next();
	public abstract boolean IsDone();
	public abstract Object CurrentItem();
}

Aggregate聚集抽象类

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

ConcreteIterator具体迭代器类，继承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

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);
	}
}

客户端

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();
		}
	}
 
}

输出结果：

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

 

四、迭代器模式优缺点

迭代器模式的优点：

• 简化了遍历方式，对于对象集合的遍历，还是比较麻烦的，对于数组或者有序列表，我们尚可以通过游标来取得，但用户需要在对集合了解很清楚的前提下，自行遍历对象，但是对于hash表来说，用户遍历起来就比较麻烦了。而引入了迭代器方法后，用户用起来就简单的多了。
• 可以提供多种遍历方式，比如说对有序列表，我们可以根据需要提供正序遍历，倒序遍历两种迭代器，用户用起来只需要得到我们实现好的迭代器，就可以方便的对集合进行遍历了。
• 封装性良好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心。

  迭代器模式的缺点：

• 对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐，大家可能都有感觉，像ArrayList，我们宁可愿意使用for循环和get方法来遍历集合。