1. 意图（Intent）

提供一种顺序访问聚合对象元素的方法，并且不暴露聚合对象的内部表示。

2. 类图（Class Diagram）

image-20201102012333804.png

  • Aggregate ：是聚合类，其中 createIterator() 方法可以产生一个 Iterator；
  • Iterator ：主要定义了 hasNext() 和 next() 方法；
  • Client ：组合了 Aggregate，为了迭代遍历 Aggregate，也需要组合 Iterator。

    3. 实现（Implementation）

具体的迭代器实现类（ConcreteIterator）中有一个指针或者说引用类型，指向了具体容器实现类（ConcreteAggregate），因此通过指针或引用操作即可 。

聚合类接口 [ Aggregate ]

  1. public interface Aggregate {
  2.     Iterator createIterator();
  3. }

某个具体的实现聚合类 [ ConcreteAggregate ]

  1. public class ConcreteAggregate implements Aggregate {
  3.     private Integer[] items; // 内部结构是一个数组
  5.     public ConcreteAggregate() {
  6.         items = new Integer[10];
  7.         for (int i = 0; i < items.length; i++) {
  8.             items[i] = i;
  9.         }
  10.     }
  12.     @Override
  13.     public Iterator createIterator() {
  14.         return new ConcreteIterator<Integer>(items);
  15.     }
  16. }

抽象的迭代器接口 [ Iterator ]

  1. public interface Iterator<Item> {
  3.     Item next();        // 返回下一个迭代器
  5.     boolean hasNext();    // 是否有下一个迭代器
  6. }

具体的迭代器实现类 [ ConcreteIterator ]

  1. public class ConcreteIterator<Item> implements Iterator {
  3.     private Item[] items;
  4.     private int position = 0;
  6.     public ConcreteIterator(Item[] items) {
  7.         this.items = items;
  8.     }
  10.     @Override
  11.     public Object next() {
  12.         return items[position++];
  13.     }
  15.     @Override
  16.     public boolean hasNext() {
  17.         return position < items.length;
  18.     }
  19. }

客户端演示：

  1. public class Client {
  3.     public static void main(String[] args) {
  4.         Aggregate aggregate = new ConcreteAggregate();
  5.         Iterator<Integer> iterator = aggregate.createIterator();
  6.         while (iterator.hasNext()) {
  7.             System.out.println(iterator.next());
  8.         }
  9.     }
  10. }

4. JDK