迭代器模式

      迭代器模式提供了一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部实现。

      有过Java编程经验的人对这种模式应该比较熟悉，因为Java内置的许多集合类型：List、Set、Map等都提供了迭代器接口，可以使用统一的方式遍历集合中的元素。下面将通过一个例子说明迭代器的使用场景，并了解一下迭代器模式的原理。

      包子店卖的有包子和饮品，对于包子和饮品的每一个条目，我们用Item来表示，Item只包含name和price两个字段：

public class Item {
  private String name;
  private double price;

  public Item(String name, double price){
    this.name = name;
    this.price = price;
  }

  // getters and setters ...
}

      由于包子会不定期更新，所以用一个ArrayList来存储目前所有的包子类别：

public class Bun {
  ArrayList<Item> buns;

  public Bun(){
    buns = new ArrayList<>();

    addBun("鲜肉包子", 1.5);
    addBun("香菇青菜包子",  1);
    addBun("鱼香肉丝包子",  1.5);
  }

  private void addBun(String name, double price){
    Item item = new Item(name, price);
    buns.add(item);
  }

  public ArrayList<Item> getBuns(){
    return buns;
  }
}

      而饮品则比较固定，一般不会增加新的类型，所以就假设固定成5种好了，对于这种需求，或许我们会选择使用数组来实现：

public class Drink {
  Item[] drinks;
  int position;
  private static final int MAX_SIZE = 5;

  public Drink(){
    drinks = new Item[MAX_SIZE];
    position = 0;

    addDrink("豆浆", 2);
    addDrink("八宝粥", 2);
    addDrink("牛奶", 2.5);
    addDrink("银耳汤", 3);
    addDrink("豆腐脑", 2);
  }

  private void addDrink(String name, double price){
    Item item = new Item(name, price);
    if(position >= MAX_SIZE){
      System.err.println("饮品已经满了。。。");
    }else{
      drinks[position++] = item;
    }
  }

  public Item[] getDrinks(){
    return drinks;
  }
}

      那么，当我们需要输出早餐店里的所有包子和饮品的时候，需要怎么写呢？我们发现包子和饮品的底层存储不一样，或许都改成ArrayList会简单很多，但是由于代码已经写好了，其他很多地方都会使用上面的代码，所以冒险修改不是一个好选择，只能麻烦一些，针对两种情况分别处理：

  public void printItems(){
    Bun bun = new Bun();
    Drink drink = new Drink();
    ArrayList<Item> buns = bun.getBuns();
    Item[] drinks = drink.getDrinks();

    //输出包子
    for(int i=0; i<buns.size(); i++){
      Item item = buns.get(i);
      System.out.println(item.getName() + ", " + item.getPrice());
    }

    //输出饮品
    for(int i=0; i<drinks.length; i++){
      System.out.println(drinks[i].getName() + ", " + drinks[i].getPrice());
    }
  }

      输出如下：

鲜肉包子, 1.5
香菇青菜包子, 1.0
鱼香肉丝包子, 1.5
豆浆, 2.0
八宝粥, 2.0
牛奶, 2.5
银耳汤, 3.0
豆腐脑, 2.0

      这里的打印逻辑的实现有几个问题：①打印方法需要知道包子和饮品的底层实现细节，这不满足封装的要求；②打印的逻辑不能扩展，如果包子店增加了馒头类型，而某位程序员打算使用Set来存储所有的馒头，那么打印方法必须要同步修改。因此，我们要做的就是隐藏底层的逻辑，对外提供统一的遍历接口，不管底层采用什么实现，对外保持一致就行。

      为了保持遍历接口的简单性，我们不打算加入太多的逻辑，具体做法是定义一个迭代器接口，包含next()和hasNext()两个方法：

public interface Iterator {
  boolean hasNext();
  Item next();
}

      为包子和饮品分别定义对应的迭代器：

public class BunIterator implements Iterator{
  ArrayList<Item> items;
  int position;

  public BunIterator(ArrayList<Item> items){
    this.items = items;
    position = 0;
  }

  @Override
  public boolean hasNext() {
    if(items == null || position >= items.size()){
      return false;
    }else{
      return true;
    }
  }

  @Override
  public Item next() {
    return items.get(position++);
  }


public class DrinkIterator implements Iterator{
  Item[] items;
  int position;

  public DrinkIterator(Item[] items){
    this.items = items;
    position = 0;
  }

  @Override
  public boolean hasNext() {
    if(position >= items.length || items[position] == null){
      return false;
    }else{
      return true;
    }
  }

  @Override
  public Item next() {
    return items[position++];
  }
}

      修改包子和饮品类，只对外提供creatorIterator方法：

public class Bun{
  ArrayList<Item> buns;

  public Bun(){
    buns = new ArrayList<>();

    addBun("鲜肉包子", 1.5);
    addBun("香菇青菜包子",  1);
    addBun("鱼香肉丝包子",  1.5);
  }

  private void addBun(String name, double price){
    Item item = new Item(name, price);
    buns.add(item);
  }

  public Iterator creatorIterator(){
    return new BunIterator(buns);
  }
}


public class Drink {
  Item[] drinks;
  int position;
  private static final int MAX_SIZE = 5;

  public Drink(){
    drinks = new Item[MAX_SIZE];
    position = 0;

    addDrink("豆浆", 2);
    addDrink("八宝粥", 2);
    addDrink("牛奶", 2.5);
    addDrink("银耳汤", 3);
    addDrink("豆腐脑", 2);
  }

  private void addDrink(String name, double price){
    Item item = new Item(name, price);
    if(position >= MAX_SIZE){
      System.err.println("饮品已经满了。。。");
    }else{
      drinks[position++] = item;
    }
  }

  public Iterator creatorIterator(){
    return new DrinkIterator(drinks);
  }
}

      接下来使用迭代器写一个新的打印方法：

public class TestIterator {

  public static void main(String[] args){
    TestIterator test = new TestIterator();
    test.printItemsWithIterator();
  }

  public void printItemsWithIterator(){
    Bun bun = new Bun();
    Drink drink = new Drink();
    Iterator bunIterator = bun.creatorIterator();
    Iterator drinkIterator = drink.creatorIterator();
    printItemsWithIterator(bunIterator);
    printItemsWithIterator(drinkIterator);
  }

  public void printItemsWithIterator(Iterator iterator){
    while(iterator.hasNext()){
      Item item = iterator.next();
      System.out.println(item.getName() + ", " + item.getPrice());
    }
  }
}

      输出如下：

鲜肉包子, 1.5
香菇青菜包子, 1.0
鱼香肉丝包子, 1.5
豆浆, 2.0
八宝粥, 2.0
牛奶, 2.5
银耳汤, 3.0
豆腐脑, 2.0

      仍然能够完成打印任务，而且使用迭代器模式使得代码简洁了许多，也更容易维护。

      以上简介了迭代器模式的用法，实际上有了Java内部的迭代器实现后，我们不再需要编写自己的迭代器，这里是为了展示迭代器的原理才自己实现。