设计模式篇 —— 迭代器模式

 

//测试类 public class IteratorMain {     public static void main(String[] args) {         List<Object> products = new ArrayList<Object>();           products.add("金箍棒");         products.add("亢龙有悔");         products.add("黯然销魂掌");         products.add("葵花点穴手");         products.add("荡剑式");         products.add("打狗棒法");         products.add("屠龙宝刀");                 AbstractObjectList list = new ProductList(products);         AbstractIterator iterator = list.createIterator();                 System.out.println("正向遍历");         while(!iterator.isLast()) {             System.out.println(iterator.getNextItem() + ",");             iterator.next();//控制角标到下一个         }         System.out.println();         System.out.println("------");           System.out.println("逆向遍历");         while(!iterator.isFirst()) {             System.out.println(iterator.getProviousItem() + ",");             iterator.previous();         }           } }

//抽象迭代器提供统一访问接口 abstract interface AbstractIterator {     public void next();     public boolean isLast();     public void previous();     public boolean isFirst();     public Object getNextItem();     public Object getProviousItem(); }

//抽象聚合对象集合 public abstract class AbstractObjectList {     //定义一个对象集合，定义增、删、查     List<Object> objects = new ArrayList<>();       public AbstractObjectList(List<Object> objects) {         this.objects = objects;     }     public void addObject(Object obj) {         this.objects.add(obj);     }       public void deleteObject(Object obj) {         this.objects.remove(obj);     }       public List<Object> getObjects() {         return this.objects;     }       //抽象迭代     public abstract AbstractIterator createIterator();  }

//具体的聚合对象类 public class ProductList extends AbstractObjectList {     public ProductList(List<Object> objects) {         super(objects);     }     //实现创建迭代器对象的具体工厂方法     @Override     public AbstractIterator createIterator() {         return new ProductIterator(this);     }       //具体迭代器实现， 不同实现遍历方式不同     //作为内部类实现     这里也可以单独抽出来类，不用内部类，一样的东西     private class ProductIterator implements AbstractIterator{              private List<Object> products;         private int cursor1;         private int cursor2;                 ProductIterator(ProductList plist) {             this.products = plist.getObjects();             cursor1 = 0;             cursor2 = products.size() - 1;         }           @Override         public void next() {             if(cursor1 < products.size()) {                 cursor1++;             }                   }             @Override         public boolean isLast() {             return (cursor1 ==  products.size());         }           @Override         public void previous() {             if(cursor2 > -1) {                 cursor2--;             }           }           @Override         public boolean isFirst() {             return (cursor2 == -1);         }           @Override         public Object getNextItem() {             return products.get(cursor1);         }           @Override         public Object getProviousItem() {             return products.get(cursor2);         }       } }

//具体迭代器实现， 不同实现遍历方式不同    这里是把上面内部类抽出来的结果， 内容不变 public class ProductIterator1 implements AbstractIterator{      private List<Object> products;     private int cursor1;     private int cursor2; … … }

将数据的遍历从聚合对象中分离出来

聚合对象只负责存储，遍历数据由迭代器完成

 

优点：

1. 同一个聚合对象，可以支持不同方式遍历，迭代器可以根据自己需要重新定义
2. 简化了聚合类的设计
3. 符合开闭原则：引入抽象层，增加聚合类或者迭代器比较方便，无需修改原有代码

 

缺点：

1. 职责分离，类个数成对增加，增加了复杂性（几乎所有解耦都设计复杂性提高）
2. 抽象的迭代器设计难度比较大，充分考虑未来需要的扩展，否则后期会修改源码

 

适用：

         聚合对象不暴露内部形式，对象访问（遍历）和对象存储解耦

         为聚合对象提供多种遍历方式；

为遍历不同聚合结构提供一个统一接口，实际内部遍历方式由实现类自己决定

 

本片内容源于刘伟老师编著，清华大学出版社《java设计模式》一书