设计模式之迭代器模式

迭代器模式：在不暴露一个聚合对象的内部表示的情况下，提供一种方法来按顺序访问该对象中的各个元素。

抽象出一个聚合类，该类提供一个方法iterator()返回这个聚合类对应的迭代器：

public interface Aggregate<T> { Iterator<T> iterator(); void add(T t); void remove(T t); }

迭代器抽象类，可以抽象出hasNext()和next()方法，供子类去实现不同的迭代方式，并定义一个默认序号：

public abstract class Iterator<T> { int index = -1; abstract T first(); abstract T next(); abstract boolean hasNext(); }

具体聚合类，继承父接口重写iterator()返回迭代器，内部保存一个容器，向外提供添加和删除元素的方法：

public class ConcreteAggregate implements Aggregate<String> { List<String> lists = new ArrayList<>(); @Override public Iterator<String> iterator() { return new ForwardIterator(this); // return new BackwardIterator(this); } @Override public void add(String s) { lists.add(s); } @Override public void remove(String s) { lists.remove(s); } }

正序迭代器，构造方法传入一个对应的聚合类，重写获取元素的几个方法：

public class ForwardIterator extends Iterator<String> { private ConcreteAggregate target; public ForwardIterator(ConcreteAggregate target) { this.target = target; } @Override public String first() { return target.lists.get(0); } @Override public String next() { return target.lists.get(++index); } @Override public boolean hasNext() { int tempIndex = index + 1; return tempIndex < target.lists.size(); } }

使用迭代器去遍历聚合类：

public class Main { public static void main(String[] args) { final ConcreteAggregate concreteTarget = new ConcreteAggregate(); for (int i = 0; i < 10; i++) { concreteTarget.add("Item " + i); } final Iterator<String> iterator = concreteTarget.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } } }

倒叙迭代器的实现，迭代器的切换只要在ConcreteAggregate类中iterator()返回不同的迭代器即可。

public class BackwardIterator extends Iterator<String> { private ConcreteAggregate target; public BackwardIterator(ConcreteAggregate target) { this.target = target; index = this.target.lists.size(); } @Override String first() { final int size = target.lists.size(); return size > 0 ? target.lists.get(size - 1) : null; } @Override String next() { return target.lists.get(--index); } @Override boolean hasNext() { final int tempIndex = index - 1; return tempIndex >= 0; } }

迭代器模式的好处在于把遍历行为抽离了出来，屏蔽了内部实现，也提供了良好的扩展性。