迭代器模式

Posted 2022-12-31 nalanziyi-liner

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

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

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

 1 public class Item 
 2   private String name;
 3   private double price;
 4 
 5   public Item(String name, double price)
 6     this.name = name;
 7     this.price = price;
 8   
 9 
10   // getters and setters ...
11 

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

 1 public class Bun 
 2   ArrayList<Item> buns;
 3 
 4   public Bun()
 5     buns = new ArrayList<>();
 6 
 7     addBun("鲜肉包子", 1.5);
 8     addBun("香菇青菜包子",  1);
 9     addBun("鱼香肉丝包子",  1.5);
10   
11 
12   private void addBun(String name, double price)
13     Item item = new Item(name, price);
14     buns.add(item);
15   
16 
17   public ArrayList<Item> getBuns()
18     return buns;
19   
20 

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

 1 public class Drink 
 2   Item[] drinks;
 3   int position;
 4   private static final int MAX_SIZE = 5;
 5 
 6   public Drink()
 7     drinks = new Item[MAX_SIZE];
 8     position = 0;
 9 
10     addDrink("豆浆", 2);
11     addDrink("八宝粥", 2);
12     addDrink("牛奶", 2.5);
13     addDrink("银耳汤", 3);
14     addDrink("豆腐脑", 2);
15   
16 
17   private void addDrink(String name, double price)
18     Item item = new Item(name, price);
19     if(position >= MAX_SIZE)
20       System.err.println("饮品已经满了。。。");
21     else
22       drinks[position++] = item;
23     
24   
25 
26   public Item[] getDrinks()
27     return drinks;
28   
29 

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

 1   public void printItems()
 2     Bun bun = new Bun();
 3     Drink drink = new Drink();
 4     ArrayList<Item> buns = bun.getBuns();
 5     Item[] drinks = drink.getDrinks();
 6 
 7     //输出包子
 8     for(int i=0; i<buns.size(); i++)
 9       Item item = buns.get(i);
10       System.out.println(item.getName() + ", " + item.getPrice());
11     
12 
13     //输出饮品
14     for(int i=0; i<drinks.length; i++)
15       System.out.println(drinks[i].getName() + ", " + drinks[i].getPrice());
16     
17   

      输出如下：

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

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

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

1 public interface Iterator 
2   boolean hasNext();
3   Item next();
4 

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

 1 public class BunIterator implements Iterator
 2   ArrayList<Item> items;
 3   int position;
 4 
 5   public BunIterator(ArrayList<Item> items)
 6     this.items = items;
 7     position = 0;
 8   
 9 
10   @Override
11   public boolean hasNext() 
12     if(items == null || position >= items.size())
13       return false;
14     else
15       return true;
16     
17   
18 
19   @Override
20   public Item next() 
21     return items.get(position++);
22   
23 
24 
25 public class DrinkIterator implements Iterator
26   Item[] items;
27   int position;
28 
29   public DrinkIterator(Item[] items)
30     this.items = items;
31     position = 0;
32   
33 
34   @Override
35   public boolean hasNext() 
36     if(position >= items.length || items[position] == null)
37       return false;
38     else
39       return true;
40     
41   
42 
43   @Override
44   public Item next() 
45     return items[position++];
46   
47 

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

 1 public class Bun
 2   ArrayList<Item> buns;
 3 
 4   public Bun()
 5     buns = new ArrayList<>();
 6 
 7     addBun("鲜肉包子", 1.5);
 8     addBun("香菇青菜包子",  1);
 9     addBun("鱼香肉丝包子",  1.5);
10   
11 
12   private void addBun(String name, double price)
13     Item item = new Item(name, price);
14     buns.add(item);
15   
16 
17   public Iterator creatorIterator()
18     return new BunIterator(buns);
19   
20 
21 
22 
23 public class Drink 
24   Item[] drinks;
25   int position;
26   private static final int MAX_SIZE = 5;
27 
28   public Drink()
29     drinks = new Item[MAX_SIZE];
30     position = 0;
31 
32     addDrink("豆浆", 2);
33     addDrink("八宝粥", 2);
34     addDrink("牛奶", 2.5);
35     addDrink("银耳汤", 3);
36     addDrink("豆腐脑", 2);
37   
38 
39   private void addDrink(String name, double price)
40     Item item = new Item(name, price);
41     if(position >= MAX_SIZE)
42       System.err.println("饮品已经满了。。。");
43     else
44       drinks[position++] = item;
45     
46   
47 
48   public Iterator creatorIterator()
49     return new DrinkIterator(drinks);
50   
51 

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

 1 public class TestIterator 
 2 
 3   public static void main(String[] args)
 4     TestIterator test = new TestIterator();
 5     test.printItemsWithIterator();
 6   
 7 
 8   public void printItemsWithIterator()
 9     Bun bun = new Bun();
10     Drink drink = new Drink();
11     Iterator bunIterator = bun.creatorIterator();
12     Iterator drinkIterator = drink.creatorIterator();
13     printItemsWithIterator(bunIterator);
14     printItemsWithIterator(drinkIterator);
15   
16 
17   public void printItemsWithIterator(Iterator iterator)
18     while(iterator.hasNext())
19       Item item = iterator.next();
20       System.out.println(item.getName() + ", " + item.getPrice());
21     
22   
23 

      输出如下：

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

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

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