迭代器模式（Iterator Pattern）

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

 

在迭代器模式中，具体迭代器角色和具体容器角色是耦合在一起的 —— 遍历算法是与容器的内部细节紧密相关的。为了使客户程序从与具体迭代器角色耦合的困境中脱离出来，避免具体迭代器角色的更换给客户程序带来的修改，迭代器模式抽象了具体迭代器角色，使得客户程序更具一般性和重用性。这被称为多态迭代。

 

迭代器模式给容器的应用带来以下好处：
      1、支持以不同的方式遍历一个容器角色。根据实现方式的不同，效果上会有差别。
      2、简化了容器的接口。但是在java Collection中为了提高可扩展性，容器还是提供了遍历的接口。
      3、对同一个容器对象，可以同时进行多个遍历。因为遍历状态是保存在每一个迭代器对象中的。

 

聚合接口类：

public interface Aggregate<E>{
	/**
	 * Iterator的泛型由Aggregate决定
	 */
	public Iterator<E> createIterator(); 
	
	public int length();
	
	public E get(int index);
	
	public void add(E obj);
}

 

聚合实现类：

public class ConcreteAggregate<E> implements Aggregate<E>{
	private List<E> items = new ArrayList<E>();
	
	public Iterator<E> createIterator() {
		return new ConcreteIterator<E>(this); 
	}
	
	public int length(){
		return items.size();
	}
	
	public E get(int index){
		return (E)items.get(index);
	}
	
	public void add(E obj){
		items.add(obj);
	}
}

 

遍历器接口类：

public interface Iterator<E>{
	public E first();
	
	public boolean hasNext();
	
	public E next();
	
	public E current();
}

 

遍历器实现类：

public class ConcreteIterator<E> implements Iterator<E>{
	private Aggregate<E> aggregate;
	private int currentIndex = 0; //遍历状态
	
	public ConcreteIterator(Aggregate<E> aggregate){
		this.aggregate = aggregate;
	}

	public E first() {
		currentIndex = 0;
		if(hasNext()){
			return aggregate.get(currentIndex);
		}else{
			return null;
		}
	}

	public boolean hasNext() {
		return (currentIndex < aggregate.length());
	}
	
	public E next() {
		currentIndex++;
		if(hasNext()){
			return aggregate.get(currentIndex);
		}else{
			return null;
		}
	}
	
	public E current(){
		return aggregate.get(currentIndex);
	}
}

 

测试类：

public class Test {
	public static void main(String[] args) {
		Aggregate<String> a = new ConcreteAggregate<String>();
		a.add("111");
		a.add("222");
		a.add("333");
		
		Iterator<String> it = a.createIterator();
		for(String s=it.first();it.hasNext();s=it.next()){
			System.out.println(s);
		}
	}
}