GOF23设计模式之迭代器模式（iterator）

一、迭代器模式概述

　　提供一种可以遍历聚合对象的方式。又称为：游标（cursor）模式

　　结构：

　　　　（1）聚合对象：存储数据

　　　　（2）迭代器：遍历数据

二、迭代器模式示例代码

　　定义：正向遍历迭代器和逆向遍历迭代器

 /**
  * 自定义迭代器接口
  * @author CL
  *
  */
 public interface MyIterator {
     /**
      * 如果仍有元素可以迭代，则返回 true
      * @return
      */
     boolean hasNext();
     /**
      * 返回迭代的下一个元素
      * @return
      */
     Object next();
     /**
      * 从迭代器指向的集合中移除迭代器返回的最后一个元素
      */
     void remove();

 }

 import java.util.ArrayList;
 import java.util.List;

 /**
  * 自定义聚合类
  * @author CL
  *
  */
 public class ConcreteAggregate {
     private List<Object> list;

     public ConcreteAggregate() {
         list = new ArrayList<Object>();
     }

     public boolean addObject(Object obj) {
         return this.list.add(obj);
     }

     public boolean removeObject(Object obj) {
         return this.list.remove(obj);
     }

     /**
      * 获得正向遍历的迭代器对象
      * @return
      */
     public MyIterator creatIterator() {
         return new ConcreteIterator(0);
     }

     /**
      * 获得逆向遍历的迭代器对象
      * @return
      */
     public MyIterator creatConverseIterator() {
         return new ConcreteIterator(list.size()-1);
     }

     /**
      * 自定义迭代器内部类
      * @author CL
      *
      */
     private class ConcreteIterator implements MyIterator {

         private int cursor;

         private final int firstValue;

         public ConcreteIterator(int cursor) {
             this.cursor = cursor;
             this.firstValue = cursor;
         }

         @Override
         public boolean hasNext() {
             if (firstValue == 0) {    //正向遍历
                 if (cursor < list.size()) {
                     return true;
                 }
             } else if (firstValue == list.size()-1) {    //逆向遍历
                 if (cursor >= 0) {
                     return true;
                 }
             }
             return false;
         }

         @Override
         public Object next() {
             if (firstValue == 0) {    //正向遍历
                 if (cursor < list.size()) {
                     return list.get(cursor++);
                 }
             } else if (firstValue == list.size()-1) {    //逆向遍历
                 if (cursor >= 0) {
                     return list.get(cursor--);
                 }
             }
             return null;
         }

         @Override
         public void remove() {
             list.remove(cursor);
         }
     }
 }

　　测试：

 /**
  * 测试迭代器对象
  * @author CL
  *
  */
 public class Client {

     public static void main(String[] args) {
         ConcreteAggregate ca = new ConcreteAggregate();
         ca.addObject("aa");
         ca.addObject("bb");
         ca.addObject("cc");
         ca.addObject("dd");

         System.out.println("正向遍历：");
         MyIterator it = ca.creatIterator();
         while (it.hasNext()) {
             System.out.println(it.next());
         }

         System.out.println("逆向遍历：");
         MyIterator it2 = ca.creatConverseIterator();
         while (it2.hasNext()) {
             System.out.println(it2.next());
         }
     }
 }

　　控制台输出：

正向遍历：
aa
bb
cc
dd
逆向遍历：
dd
cc
bb
aa

三、迭代器模式常见开发应用场景

　　（1）JDK内置的迭代器（List / Set）

　　　　  List / Set 实现了 Collection 接口，Collection 实现了 Iterator 接口。

　　（2）…………