设计模式--迭代器模式

1. 迭代器模式(Interator)提供了一种顺序访问一个聚合对象中的各种元素，而又不暴露该对象内部。

2. 迭代器模式的UML图

   

3. Interator，遍历器角色，定义遍历元素需要的方法，一般会有三个方法，next(),hasNext(),remove()；Concrete Interator具体迭代器，完成集合的迭代；Aggegate一般是一个接口，提供了intorator()的方法，例如Collection， List, Set等接口；Concrete Aggegate具体的容器类

4. 迭代器模式的代码实现

   1. 创建一个抽象迭代器接口

      /**
       * 抽象迭代器,提供迭代过程中的方法
       */
      public interface Interator {
      
          boolean hasNext();
      
          Object next();
      
      }
      

   2. 创建一个抽象容器接口

      /**
       * 抽象容器类，需要被遍历的对象，提供增删改查容器的方法
       * 需要提供获取迭代器的方法
       */
      public interface ListAggregate {
      
          void add(Object object);
      
          Object get(int index);
      
          int getSize();
      
          //获取迭代器
          Interator getInterator();
      }
      

   3. 创建一个具体的迭代器(包含对容器的引用)

      /**
       * 具体迭代器，需要对容器进行迭代
       */
      public class ConcreteInterator implements Interator {
      
          //具体迭代类要与容器角色有一个关系
          private ListAggregate listAggregate;
          private int index;
      
          public ConcreteInterator(ListAggregate listAggregate) {
              this.listAggregate = listAggregate;
          }
      
          @Override
          public boolean hasNext() {
              if(index >= listAggregate.getSize()){
                  return false;
              }
              return true;
          }
      
          @Override
          public Object next() {
              Object o = listAggregate.get(index);
              index++;
              return o;
          }
      
      }
      

   4. 创建一个具体的容器类

      /**
       * 具体容器类
       * 实现getInterator，找到属于自己的interator
       */
      public class ConcreteListAggregate implements ListAggregate{
      
          private Object[] list;
          private int size = 0;
          private int index = 0;
      
          public ConcreteListAggregate() {
              size = 0;
              index = 0;
              list = new Object[100];
          }
      
          @Override
          public void add(Object object) {
              list[index++] = object;
              size++;
          }
      
          @Override
          public Object get(int index) {
              return list[index];
          }
      
          @Override
          public int getSize() {
              return size;
          }
      
          @Override
          public Interator getInterator() {
              return new ConcreteInterator(this);
          }
      }
      

   5. 创建测试类

      public class Test {
          public static void main(String[] args) {
              ListAggregate list = new ConcreteListAggregate();
              list.add("a");
              list.add("b");
              list.add("c");
              list.add("d");
              list.add("e");
              Interator interator = list.getInterator();
              while (interator.hasNext()){
                  System.out.print(interator.next().toString() + " ");
              }
          }
      }
      

5. 迭代器模式的优点

   1. 支持以不同的方式遍历一个容器对象
   2. 迭代器简化了聚合类
   3. 在迭代器模式中，增加新的聚合类和迭代器类都很方便，无需修改原有代码

6. 迭代器模式的缺点

   1. 由于迭代器模式将存储数据与遍历数据的职责分离，增加新的聚合类需要增减对应的迭代器类，类的个数承兑增加，在一定程度上增加了系统的复杂性

7. 迭代器模式的使用场景

   1. 访问一个聚合对象的内容而无需暴露它的内部
   2. 需要为聚合对象提供多种遍历方式
   3. 为遍历不同的聚合结构提供一个统一的接口

8. JDK中对迭代器模式的使用

   java.util.Interator