设计模式-迭代器模式

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

        当需要访问一个聚合对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。

package com.iterator;

public abstract class Iterator {
	public abstract Object first();
	public abstract Object next();
	public abstract boolean hasNext();
}

package com.iterator;

public class ConcreteIterator extends Iterator{

	private ConcreteAggregate aggregate;
	private int count = -1;
	public ConcreteIterator(ConcreteAggregate aggregate) {
		this.aggregate = aggregate;
	}
	@Override
	public Object first() {
		return aggregate.getItem(0);
	}

	@Override
	public Object next() {
		count++;
		Object ret = null;
		if(count < aggregate.getCount()) {
			ret = aggregate.getItem(count);
		}
		return ret;
	}

	@Override
	public boolean hasNext() {
		if((count + 1) < aggregate.getCount()) {
			return true;
		}
		return false;
	}
}

package com.iterator;

public abstract class Aggregate {
	public abstract Iterator createIterator();
}

package com.iterator;

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

public class ConcreteAggregate extends Aggregate{
	public List<Object> items = new ArrayList<Object>();
	@Override
	public Iterator createIterator() {
		return new ConcreteIterator(this);
	}
	
	public int getCount() {
		return items.size();
	}
	
	public Object getItem(int index) {
		return items.get(index);
	}
	
	

}

package com.iterator;

public class Test {
	public static void main(String[] args) {
		ConcreteAggregate aggregate = new ConcreteAggregate();
		aggregate.items.add("1");
		aggregate.items.add("2");
		aggregate.items.add("3");
		aggregate.items.add("4");
		aggregate.items.add("5");
		aggregate.items.add("6");
		
		Iterator i = new ConcreteIterator(aggregate);
		while(i.hasNext()) {
			System.err.println(i.next());
		}
	}
}

        Iterator迭代器抽象类。

        Aggregate聚集抽象类。

        ConcreteIterator具体迭代器类，继承Iterator。

        ConcreteAggregate具体聚集类，继承Aggregate。

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

PS：摘录于《大话设计模式》