设计模式 with Python 9：迭代器模式

我们在初学编程语言的时候，除了在诸如变量、控制流程、面向对象这些编程基础内容上会话费大量精力以外，编程语言的内建集合（Collection）或者说内建容器，也同样是重中之重。无论是常用的数组、链表、映射或者是不常用的队列、堆栈等，都需要我们话费大量时间去学习，因为你工作后会发现编写程序的工作中有很大一部分时间是在与这些集合组件打交道。

而我们今天要讨论的迭代器模式，就是为了对于不同内部实现的集合提供一种统一的迭代方式，从而对于客户端来说屏蔽不需要了解的内部实现，可以简单地进行迭代、遍历工作，这是非常棒的一个想法。

如《Head First 设计模式》中的示例那般，在这里我围绕餐馆菜单来进行举例说明。

注意：因为Python和Java在迭代器实现上有较大不同，所以这里使用Java进行举例说明，在文末会集中说明Python方式的实现应该是怎样的。

外卖服务

假如我们想创建一个外卖服务，为附近的几家餐馆提供统一的线上外卖服务，联系了几家餐馆后，它们给我们提供了用于接入的SDK，简单整合这些SDK后整个系统大概长这样：

虽然表示菜品的菜单项MenuItem已经统一为一个类型，但烧烤店的菜单BarbecueHouseMenu采用数组进行存储，而汉堡店的菜单BurgerJointMenu采用数组列表ArrayList进行存储。很自然，对于这两种不同的集合我们需要使用不同的方式进行遍历输出。

代码相对简单，这里只展示最后的外卖服务TakeOutService类与测试输出，完整代码见take_out_v1/src：

package pattern9.take_out_v1.src;import java.util.ArrayList;/*** @author 70748* @version 1.0* @created 05-7��-2021 14:44:27*/
public class TakeOutService {private BarbecueHouseMenu barbecueHouseMenu;private BurgerJointMenu burgerJointMenu;public TakeOutService() {this.barbecueHouseMenu = new BarbecueHouseMenu();this.burgerJointMenu = new BurgerJointMenu();}public void finalize() throws Throwable {}public void printMenu() {System.out.println("This is a Barbecue House menu:");MenuItem[] menuItems = this.barbecueHouseMenu.getMenuItems();for (int i = 0; i < menuItems.length; i++) {if (menuItems[i] != null) {System.out.println(menuItems[i]);}}System.out.println("This is a Burger Joint menu:");ArrayList<MenuItem> items = this.burgerJointMenu.getMenuItems();for (int i=0;i<items.size();i++){MenuItem menuItem = items.get(i);System.out.println(menuItem);}}public static void main(String[] args) {TakeOutService takeOutService = new TakeOutService();takeOutService.printMenu();}
}// end TakeOutService// This is a Barbecue House menu:
// 菜品名称：烤羊肉串      价格：3.0       是否素菜：否
// 菜品名称：烤羊排        价格：10.0      是否素菜：否
// 菜品名称：烤韭菜        价格：2.0       是否素菜：是
// 菜品名称：烤茄子        价格：5.0       是否素菜：是
// 菜品名称：烤土豆        价格：1.0       是否素菜：是
// This is a Burger Joint menu:
// 菜品名称：田园鸡腿堡    价格：15.0      是否素菜：否
// 菜品名称：蔬菜沙拉      价格：10.0      是否素菜：是
// 菜品名称：巨无霸        价格：20.0      是否素菜：否
// 菜品名称：薯条  价格：5.0       是否素菜：是
// 菜品名称：可乐  价格：10.0      是否素菜：是

在这里，我们使用了两种不同的方式遍历菜单项，这是因为两个菜单返回的包含菜单项MenuItem的集合是不同的类型，所以需要使用不同的方式进行迭代。

正如本文一开始所说的，这正是迭代器模式的“用武之地”。

迭代器模式

如果你接触过Python，那肯定听说过迭代器，迭代器可以说深入了Python本身，但这里说的是一般性的迭代器模式，所以可能会和Python的迭代器实现有所差别。

我们看标准的迭代器UML：

这个设计本身很简单，Iterator是一个标识迭代器的接口，有两个方法：hasNext表示能否从当前的迭代器中获取到下一个元素，next是直接从迭代器中获取到下一个元素。Iterable接口表示一个可迭代的类型，具有一个方法iterator，这个方法会返回一个迭代器，即实现了Iterator接口的类型。而具体的迭代器ConcreteIterator和具体的可迭代类型会分别实现Iterator和Iterable接口。

这里的关键在于，通过实现Iterator和Iterable接口我们可以创建具有统一接口的迭代器和可迭代对象，通过这些多出来的抽象层次，我们可以让外部的客户端程序在不依赖具体集合的实现的情况下单独使用迭代器进行对集合中的元素的遍历。所以通常ConcreteIterator会包含一个集合的句柄用于实现hasNext和next的具体逻辑。

下面我们通过对外卖服务使用迭代器模式重构，来说明迭代器模式具体是如何实现的。

使用迭代器模式

先创建迭代器和可迭代对象接口：

package pattern9.take_out_v2.src;public interface Iterator {public boolean hasNext();public Object next();
}

package pattern9.take_out_v2.src;public interface Iterable {public Iterator iterator();
}

分别针对两种不同的集合创建对应的具体迭代器：

package pattern9.take_out_v2.src;public class ArrayIterator implements Iterator {private Object[] array;private int currentIndex = -1;public ArrayIterator(Object[] array) {this.array = array;}@Overridepublic boolean hasNext() {if (currentIndex >= array.length - 1 || array[currentIndex+1] == null) {return false;}return true;}@Overridepublic Object next() {Object next = array[currentIndex + 1];currentIndex++;return next;}}

package pattern9.take_out_v2.src;import java.util.ArrayList;public class ArrayListIterator implements Iterator {private ArrayList<Object> arrayList;private int nextIndex = 0;public ArrayListIterator(ArrayList arrayList) {this.arrayList = arrayList;}@Overridepublic boolean hasNext() {if (nextIndex >= arrayList.size()) {return false;}return true;}@Overridepublic Object next() {return arrayList.get(nextIndex++);}}

菜单类BarbecueHouseMenu和BurgerJointMenu实现Iterable接口，改动的代码几乎一致，这里仅展示其中之一：

package pattern9.take_out_v2.src;import java.util.ArrayList;/*** @author 70748* @version 1.0* @created 05-7��-2021 14:44:27*/
public class BurgerJointMenu implements Iterable {private ArrayList<MenuItem> menuItems = new ArrayList<MenuItem>();public BurgerJointMenu() {this.addMenuItem(new MenuItem("田园鸡腿堡", 15, false));this.addMenuItem(new MenuItem("蔬菜沙拉", 10, true));this.addMenuItem(new MenuItem("巨无霸", 20, false));this.addMenuItem(new MenuItem("薯条", 5, true));this.addMenuItem(new MenuItem("可乐", 10, true));}public void finalize() throws Throwable {}private void addMenuItem(MenuItem menuItem) {this.menuItems.add(menuItem);}@Overridepublic Iterator iterator() {return new ArrayListIterator(this.menuItems);}
}// end BurgerJointMenu

修改测试代码：

package pattern9.take_out_v2.src;/*** @author 70748* @version 1.0* @created 05-7��-2021 14:44:27*/
public class TakeOutService {private BarbecueHouseMenu barbecueHouseMenu;private BurgerJointMenu burgerJointMenu;public TakeOutService() {this.barbecueHouseMenu = new BarbecueHouseMenu();this.burgerJointMenu = new BurgerJointMenu();}public void finalize() throws Throwable {}public void printMenu() {System.out.println("This is a Barbecue House menu:");this.printMenu(this.barbecueHouseMenu);System.out.println("This is a Burger Joint menu:");this.printMenu(this.burgerJointMenu);}private void printMenu(Iterable iterable) {Iterator iterator = iterable.iterator();while (iterator.hasNext()) {MenuItem menuItem = (MenuItem) iterator.next();System.out.println(menuItem);}}public static void main(String[] args) {TakeOutService takeOutService = new TakeOutService();takeOutService.printMenu();}
}// end TakeOutService// This is a Barbecue House menu:
// 菜品名称：烤羊肉串 价格：3.0 是否素菜：否
// 菜品名称：烤羊排 价格：10.0 是否素菜：否
// 菜品名称：烤韭菜 价格：2.0 是否素菜：是
// 菜品名称：烤茄子 价格：5.0 是否素菜：是
// 菜品名称：烤土豆 价格：1.0 是否素菜：是
// This is a Burger Joint menu:
// 菜品名称：田园鸡腿堡 价格：15.0 是否素菜：否
// 菜品名称：蔬菜沙拉 价格：10.0 是否素菜：是
// 菜品名称：巨无霸 价格：20.0 是否素菜：否
// 菜品名称：薯条 价格：5.0 是否素菜：是
// 菜品名称：可乐 价格：10.0 是否素菜：是

这里的要点在于，我们只关心是否可以获取到两个菜单相关的迭代器，并不关心这两个迭代器如何实现。所以在实现中其实迭代器也可以通过持有两种菜单的引用，而非直接持有数组或者数组列表的引用，同样可以达到目的，但从通用性的角度讲，显然创建数组和数组列表的迭代器比创建两个菜单的迭代器更具有通用性，如果你的其它地方需要数组迭代器，直接拿过去用就是了。

上面我们展示了如何从头到尾在外卖服务中使用一套自己创建的迭代器模式，但其实Java本身是内建了迭代器的相关接口和组件的，我们并不需要从头到尾自己创建，只需要直接使用即可。

Java内建的迭代器接口

Java的内建可迭代接口是java.lang.Iterable，迭代器接口为java.util.Iterator。只要用这两个内建接口替换我们自己创建的相应接口即可。

比如这样：

package pattern9.take_out_v3.src;import java.util.Iterator;public class ArrayIterator<T> implements Iterator<T> {private T[] array;private int currentIndex = -1;

这里使用泛型改写ArrayIterator，以避免可能的warning。关于Java的泛型，可以阅读Java 泛型。

至于ArrayListIterator，可以完全删除，因为Java所有的内置集合都已经实现了Iterable接口，我们直接调用iterator获取迭代器即可。

比如这样：

 @Overridepublic Iterator<MenuItem> iterator() {return this.menuItems.iterator();}

剩余改动的代码这里不一一展示，可以在take_out_v3/src获取完整代码。

单一责任原则

迭代器模式体现了一个设计模式原则：单一责任原则。

这个原则指的是，对于我们创建的一个具体的类，应当让其承担相对单一的责任或任务。

比如集合相关的类，其核心任务就是管理内部的元素，比如添加、删除元素。而迭代任务并非其核心任务，好的做法是从其中分离出来，让迭代器去“代劳”，而集合本身只需要关心元素管理即可。

这就是单一责任原则。看起来似乎很容易，但是如果你接触编程久了就会知道，对类的抽象层次，或者说类定义的粒度的把握相当困难，我们都清楚越是将抽象层次细分，越是将类的粒度缩小，越可以提高设计的灵活性，但与此同时，会产生庞大的类数目，会让管理和维护以及工作量随之上升，所以这之间要有所取舍，仔细衡量以制定一个合适的程度。

当然，这种把握属于经验的一部分，并没有捷径或者准则可以提供，唯一获取的方式是持之以恒。

组合模式

我们现在的外卖服务已经运行的很完美了，如果没有新需求的话。

假设我们有一个新的需求：汉堡店想提供一个“活动菜单”，比如和某某知名游戏联名，当然我们并不需要用户说出某种羞耻的台词才能获取到这个菜单