java设计模式（二十）迭代器模式（Iterator Pattern）

1、模式介绍：

迭代器模式是一种行为设计模式，它允许客户端通过统一的方式访问聚合对象中的各个元素，而不必暴露其内部表示。通过迭代器模式，可以在不知道聚合对象内部结构的情况下，顺序访问其中的元素。

2、应用场景：

当需要访问一个聚合对象的内容而无需暴露其内部表示时，可以使用迭代器模式。这样客户端可以通过迭代器依次访问聚合对象中的元素。
当需要对聚合对象有多种遍历方式时，可以通过不同的迭代器实现类来实现不同的遍历策略。

3、优点：

分离了聚合对象的遍历行为，使得聚合对象的内部变化不会影响到客户端的遍历操作。
提供了一种统一的接口，客户端可以使用统一的方式遍历不同的聚合对象。

4、缺点：

增加了类的个数，因为每个聚合对象都需要一个对应的迭代器。
在某些情况下，使用迭代器可能会导致性能上的损失，因为迭代器模式在遍历过程中会增加额外的对象创建和方法调用。

5、代码示例：

/**
 * 迭代器接口
 */
public interface IteratorPatternIterator<T> {
	boolean hasNext();
	T next();
}

/**
 * 聚合接口
 */
public interface Aggregate<T> {
	IteratorPatternIterator<T> createIterator();
}

/**
 * 具体迭代器实现
 */
public class ConcreteIterator<T> implements IteratorPatternIterator<T> {
	private List<T> elements;
	private int position;

	public ConcreteIterator(List<T> elements) {
		this.elements = elements;
		this.position = 0;
	}

	@Override
	public boolean hasNext() {
		return position < elements.size();
	}

	@Override
	public T next() {
		return elements.get(position++);
	}
}

/**
 * 具体聚合实现
 */
public class ConcreteAggregate<T> implements Aggregate<T> {
	private List<T> elements = new ArrayList<>();

	public void add(T element) {
		elements.add(element);
	}

	@Override
	public IteratorPatternIterator<T> createIterator() {
		return new ConcreteIterator<>(elements);
	}
}

/**
 * 实现
 */
public class IteratorClient  {
	public static void main(String[] args) {
		ConcreteAggregate<String> aggregate = new ConcreteAggregate<>();
		aggregate.add("Item 1");
		aggregate.add("Item 2");
		aggregate.add("Item 3");

	 	IteratorPatternIterator<String> iterator = aggregate.createIterator();

	 	while (iterator.hasNext()) {
	  		String item = iterator.next();
	  		System.out.println("Item: " + item);
	 	}
	}
}

6、示例讲解:

IteratorPatternIterator 定义了迭代器的接口，包括 hasNext() 和 next() 方法。
Aggregate 定义了聚合对象的接口，其中包括 createIterator() 方法用于创建迭代器。
ConcreteIterator 是具体的迭代器实现，负责遍历 List 中的元素。
ConcreteAggregate 是具体的聚合对象实现，维护一个 List 来存储元素，并实现了 createIterator() 方法以生成对应的迭代器。
在 main 方法中，创建了一个具体的聚合对象 ConcreteAggregate，添加了一些元素，并使用迭代器依次访问这些元素并打印输出。