迭代器模式

      迭代器模式提供了一種方法順序訪問一個聚合對象中的各個元素，而又不暴露其內部實現。

      有過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內部的迭代器實現后，我們不再需要編寫自己的迭代器，這里是為了展示迭代器的原理才自己實現。