提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。

    【角色】

    • 迭代器接口（Iterator）: 负责定义、访问和遍历元素的接口。
    • 具体迭代器类（ConcreteIterator）: 目的主要是实现迭代器接口，并记录遍历的当前位置。
    • 容器接口（Aggregate）: 负责提供创建具体迭代器角色的接口。

    • 具体容器类（ConcreteAggregate）: 具体迭代器角色与该容器相关联。

      1. /**
      2. * 迭代器接口
      3. */
      4. public interface Iterator<E> {
      6.   /**
      7.    * 是否还有下一个元素
      8.    * @return
      9.    */
      10.   boolean hasNext();
      12.   /**
      13.    * 返回当前位置的元素并将位置移动到下一位
      14.    * @return
      15.    */
      16.   E next();
      17. }
      1. /**
      2. * 具体迭代器类
      3. */
      4. public class ConcreteIterator<E> implements Iterator<E> {
      6.   /**
      7.    * 记录迭代位置
      8.    */
      9.   private int cursor = 0;
      11.   private List<E> list;
      13.   public ConcreteIterator(List<E> list) {
      14.       this.list = list;
      15.   }
      17.   @Override
      18.   public boolean hasNext() {
      19.       return cursor != list.size();
      20.   }
      22.   @Override
      23.   public E next() {
      24.       E obj = null;
      25.       if (hasNext()) {
      26.           obj = list.get(cursor++);
      27.       }
      28.       return obj;
      29.   }
      30. }
      1. /**
      2. * 容器接口
      3. */
      4. public interface Aggregate<E> {
      6.   /**
      7.    * 添加
      8.    * @param e
      9.    */
      10.   void add(E e);
      12.   /**
      13.    * 删除
      14.    * @param e
      15.    */
      16.   void remove(E e);
      18.   /**
      19.    * 获取迭代器
      20.    * @return
      21.    */
      22.   Iterator<E> iterator();
      23. }
      1. /**
      2. * 具体容器类
      3. */
      4. public class ConcreteAggregate<E> implements Aggregate<E> {
      6.   /**
      7.    * 模拟具体容器
      8.    */
      9.   private List<E> list = new ArrayList<>();
      11.   @Override
      12.   public void add(E e) {
      13.       list.add(e);
      14.   }
      16.   @Override
      17.   public void remove(E e) {
      18.       list.remove(e);
      19.   }
      21.   @Override
      22.   public Iterator iterator() {
      23.       return new ConcreteIterator(list);
      24.   }
      25. }
      1. public class IteratorTest {
      2.   public static void main(String[] args) {
      3.       // 创建容器
      4.       Aggregate aggregate = new ConcreteAggregate();
      5.       aggregate.add(1);
      6.       aggregate.add(2);
      7.       aggregate.add(3);
      8.       aggregate.add(4);
      10.       // 获取迭代器
      11.       Iterator iterator = aggregate.iterator();
      12.       while (iterator.hasNext()) {
      13.           System.out.println("迭代：" + iterator.next());
      14.       }
      15.   }
      16. }
      17. ----输出----
      18. 迭代：1
      19. 迭代：2
      20. 迭代：3
      21. 迭代：4