设计模式-迭代器模式以及JDK类库中的应用

迭代器模式

定义

按照一定顺序遍历一个聚合对象内部的每一个元素，而不需要暴露对象内部的细节。

结构

Iterator：抽象迭代器类，负责定义获取第一个元素、获取下一个元素、获取当前元素、判断是否存在下一个元素等接口。

ConcreteIterator：具体迭代器类，继承抽象迭代器类，实现具体的接口方法。

Aggregate：抽象聚集类，定义一个创建迭代器类的接口。

ConcreteAggregate：具体聚合类，内部存在一个集合对象，继承抽象聚合类，实现创建迭代器类接口。

类图

Iterator：

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

ConcreteIterator：

public class ConcreteIterator extends Iterator {

	protected ConcreteAggregate concreteAggregate;
	protected int current = 0;

	public ConcreteIterator(ConcreteAggregate concreteAggregate) {
		this.concreteAggregate = concreteAggregate;
	}

	@Override
	public Object first() {
		if (concreteAggregate.getList().size() > 0) {
			return concreteAggregate.getList().get(0);
		}
		return null;
	}

	@Override
	public Object next() {
		Object rel = null;
		current++;
		if (current < concreteAggregate.getList().size()) {
			rel = concreteAggregate.getList().get(current);
		}
		return rel;
	}

	@Override
	public boolean hasNext() {
		return current < concreteAggregate.getList().size() ? true : false;
	}

	@Override
	public Object currentItem() {
		return concreteAggregate.getList().get(current);
	}

}

Aggregate：

public interface Aggregate {
	public Iterator createIterator();
}

ConcreteAggregate：

public class ConcreteAggregate implements Aggregate {

	private ArrayList<String> list = new ArrayList<String>();
	@Override
	public Iterator createIterator() {
		return new ConcreteIterator(this);
	}
	public ArrayList<String> getList() {
		return list;
	}

}

测试类：

	public static void main(String[] args) {
		ConcreteAggregate aggregate = new ConcreteAggregate();
		aggregate.getList().add("1");
		aggregate.getList().add("2");
		aggregate.getList().add("3");
		Iterator iterator = aggregate.createIterator();
		System.out.println(iterator.first());//1
		while(iterator.hasNext()){
			System.out.println(iterator.currentItem());
			iterator.next();
		}
	}

测试结果：

优点

1.在不暴露聚合对象内部细节的前提下，可以遍历该聚合对象的每一个元素。

2.支持多种遍历聚合对象的方法，只需要增加新的具体迭代器类即可。

缺点

针对每一个聚合对象都需要增加一个抽象迭代器和一个具体迭代器类，增加了系统复杂度。

JDK类库中的迭代器模式

java.util.Iterator

举个栗子：

		List<String> list = new ArrayList<String>();
		list.add("1");
		list.add("1");
		list.add("1");
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());//打印111
		}

在这个例子中list.iterator()方法实例化一个Iterator接口的子类Itr，Itr实现了hasNext、next、remove接口，这里Itr是一个内部类，只服务于ArrayList类，好处就是Itr可以直接操作ArrayList中的元素对象。

java.util.Enumeration