【再谈设计模式】迭代器模式~遍历集合元素的利器

一、引言

        在软件开发的世界里，数据结构和算法是构建高效程序的基石。而在处理集合类型的数据时，我们常常需要一种灵活的方式来遍历其中的元素。这时候，迭代器模式就闪亮登场了。它就像是一把万能钥匙，可以打开不同集合类型的遍历之门，无论是数组、链表还是树状结构等。迭代器模式提供了一种统一的、标准的遍历方式，使得代码的可维护性和扩展性大大增强。

二、定义与描述

        迭代器模式是一种行为设计模式，它提供了一种方法来顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。简单来说，就是将遍历的逻辑从被遍历的对象中分离出来，放入一个专门的迭代器对象中。这样，不同的集合对象可以复用相同的迭代器逻辑，而集合对象本身只需要关注自身的数据存储和管理。

三、抽象背景

        在很多应用场景中，我们需要处理各种不同类型的集合。如果直接在每个集合类中编写遍历逻辑，那么代码将会变得非常冗余和难以维护。例如，我们可能有一个存储整数的数组，一个存储字符串的链表，还有一个存储自定义对象的树结构。如果要分别为它们编写遍历代码，不仅工作量大，而且当需求发生变化时（比如增加一种新的遍历方式），需要在每个类中进行修改。迭代器模式通过将遍历逻辑抽象出来，解决了这个问题。

 

四、适用场景与现实问题解决

处理多种集合类型

        当程序中存在多种不同类型的集合，如数组、链表、栈、队列等，并且需要对它们进行遍历操作时，迭代器模式可以提供统一的遍历接口。这样，在编写遍历这些集合的代码时，可以使用相同的迭代器接口，而不需要关心具体的集合类型。

 

隐藏集合内部结构

        有时候，我们不希望外部代码直接访问集合的内部结构（比如数组的下标操作或者链表的指针操作）。迭代器模式可以将集合的遍历操作封装起来，只暴露必要的遍历接口，从而提高了集合的安全性和封装性。

支持多种遍历方式

        对于同一个集合，可能存在多种遍历方式，如正向遍历、反向遍历等。通过迭代器模式，可以方便地实现多种遍历方式，并且可以在不修改集合类的情况下添加新的遍历方式。

五、迭代器模式的现实生活的例子

餐厅菜单

        想象一家餐厅的菜单，菜单上有一系列的菜品。服务员（相当于迭代器）可以按照菜单上菜品的顺序（正向遍历）或者从最后一道菜开始（反向遍历）向顾客介绍菜品，而顾客不需要知道菜单是如何存储菜品信息的（菜单的内部结构）。

 

音乐播放器

        在音乐播放器中，播放列表可以看作是一个集合，而播放顺序（顺序播放、随机播放等）可以通过不同的迭代器来实现。用户不需要知道播放列表是如何存储音乐文件的，只需要通过播放器提供的播放功能（迭代器接口）来享受音乐。

六、初衷与问题解决

初衷：

        为了将遍历集合的逻辑从集合类本身分离出来，以提高代码的可维护性、可扩展性和复用性。

        提供一种统一的遍历接口，使得不同类型的集合可以使用相同的遍历方式，同时隐藏集合的内部结构。

问题解决：

        通过创建独立的迭代器类，避免了在每个集合类中编写重复的遍历逻辑，减少了代码冗余。

        当需要修改遍历逻辑或者添加新的遍历方式时，只需要在迭代器类中进行操作，而不需要修改集合类，遵循了开闭原则。

七、代码示例 Java

类图：

import java.util.Iterator; // 定义一个集合接口 interface MyCollection { Iterator createIterator(); } // 具体的集合类，这里以数组为例 class MyArray implements MyCollection { private String[] items; public MyArray(String[] items) { this.items = items; } @Override public Iterator createIterator() { return new MyArrayIterator(); } // 内部的迭代器类 private class MyArrayIterator implements Iterator { private int index = 0; @Override public boolean hasNext() { return index < items.length; } @Override public Object next() { return items[index++]; } } } public class Main { public static void main(String[] args) { String[] array = {"item1", "item2", "item3"}; MyArray myArray = new MyArray(array); Iterator iterator = myArray.createIterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } } }

流程图：

 时序图：

C++ #include <iostream> #include <vector> // 迭代器抽象类 class Iterator { public: virtual bool hasNext() = 0; virtual int next() = 0; }; // 集合抽象类 class Collection { public: virtual Iterator* createIterator() = 0; }; // 具体的集合类，这里以vector为例 class MyVector : public Collection { private: std::vector<int> items; public: MyVector(std::vector<int> items) : items(items) {} Iterator* createIterator() override { return new MyVectorIterator(this); } // 内部的迭代器类 class MyVectorIterator : public Iterator { private: MyVector* collection; size_t index = 0; public: MyVectorIterator(MyVector* collection) : collection(collection) {} bool hasNext() override { return index < collection->items.size(); } int next() override { return collection->items[index++]; } }; }; int main() { std::vector<int> vector = {1, 2, 3}; MyVector myVector(vector); Iterator* iterator = myVector.createIterator(); while (iterator->hasNext()) { std::cout << iterator->next() << std::endl; } delete iterator; return 0; } Python # 定义迭代器抽象类 class Iterator: def hasNext(self): pass def next(self): pass # 定义集合抽象类 class Collection: def createIterator(self): pass # 具体的集合类，这里以列表为例 class MyList(Collection): def __init__(self, items): self.items = items def createIterator(self): return MyListIterator(self) # 内部的迭代器类 class MyListIterator(Iterator): def __init__(self, collection): self.collection = collection self.index = 0 def hasNext(self): return self.index < len(self.collection.items) def next(self): item = self.collection.items[self.index] self.index += 1 return item my_list = MyList([1, 2, 3]) iterator = my_list.createIterator() while iterator.hasNext(): print(iterator.next()) Go package main import "fmt" // 迭代器接口 type Iterator interface { hasNext() bool next() interface{} } // 集合接口 type Collection interface { createIterator() Iterator } // 具体的集合类，这里以切片为例 type MySlice struct { items []interface{} } func (m *MySlice) createIterator() Iterator { return &MySliceIterator{ slice: m, index: 0, } } // 内部的迭代器类 type MySliceIterator struct { slice *MySlice index int } func (m *MySliceIterator) hasNext() bool { return m.index < len(m.slice.items) } func (m *MySliceIterator) next() interface{} { item := m.slice.items[m.index] m.index++ return item } func main() { mySlice := MySlice{items: []interface{}{1, 2, 3}} iterator := mySlice.createIterator() for iterator.hasNext() { fmt.Println(iterator.next()) } } 八、迭代器模式的优缺点 优点

单一职责原则

        迭代器模式将遍历集合的职责分离到迭代器类中，使得集合类只需要关注自身的数据存储和管理，符合单一职责原则。

开闭原则

        当需要添加新的遍历方式或者修改遍历逻辑时，只需要在迭代器类中进行操作，不需要修改集合类，遵循了开闭原则。

统一的遍历接口

        为不同类型的集合提供了统一的遍历接口，使得代码的可维护性和可读性提高。

缺点

增加复杂性

        引入了额外的迭代器类，使得代码结构相对复杂，对于简单的遍历操作可能会显得有些冗余。

性能开销

        在某些情况下，创建和使用迭代器可能会带来一定的性能开销，比如在频繁遍历小型集合时。

特点描述单一职责原则迭代器模式将遍历集合的职责分离到迭代器类中，使得集合类只需要关注自身的数据存储和管理，符合单一职责原则。开闭原则当需要添加新的遍历方式或者修改遍历逻辑时，只需要在迭代器类中进行操作，不需要修改集合类，遵循了开闭原则。统一的遍历接口为不同类型的集合提供了统一的遍历接口，使得代码的可维护性和可读性提高。增加复杂性引入了额外的迭代器类，使得代码结构相对复杂，对于简单的遍历操作可能会显得有些冗余。性能开销在某些情况下，创建和使用迭代器可能会带来一定的性能开销，比如在频繁遍历小型集合时。 九、迭代器模式的升级版 - 内部迭代器

        内部迭代器是迭代器模式的一种改进形式。在传统的迭代器模式中，迭代操作是由外部的迭代器对象控制的，而内部迭代器则是将迭代逻辑封装在集合类内部。例如，在JavaScript中，可以定义一个数组的forEach方法，这个方法就是一种内部迭代器。它接受一个回调函数作为参数，然后在数组内部自动遍历每个元素，并将元素传递给回调函数进行处理。内部迭代器的优点是使用更加方便，代码更加简洁，缺点是灵活性相对较差，不太适合需要复杂遍历逻辑的场景。