设计模式笔记 – 迭代器模式

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

迭代器模式属于行为型模式。

介绍

• 意图： 提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。
• 主要解决： 不同的方式来遍历整个整合对象。
• 何时使用： 遍历一个聚合对象。
• 如何解决： 把在元素之间游走的责任交给迭代器，而不是聚合对象。
• 关键代码： 定义接口：hasNext, next。
• 优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。
• 缺点： 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
• 应用实例： JAVA 中的 iterator。
• 使用场景： 1、访问一个聚合对象的内容而无须暴露它的内部表示。 2、需要为聚合对象提供多种遍历方式。 3、为遍历不同的聚合结构提供一个统一的接口。
• 注意事项： 迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

示例

我们将创建一个叙述导航方法的 Iterator 接口和一个返回迭代器的 Container 接口。实现了 Container 接口的实体类将负责实现 Iterator 接口。

IteratorPatternDemo，我们的演示类使用实体类 NamesRepository 来打印 NamesRepository 中存储为集合的 Names。

Java 实现

创建接口

public interface Iterator {
    public boolean hacNext();
    public Object next();
}

public interface Container {
    public Iterator getIterator();
}

创建实现了Container接口的实体类

public class NameRepository implements Container {
    public String names[] = {"Robert", "John", "Julie", "Lora"};
    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }
    private class NameIterator implements Iterator {
        int index;
        @Override
        public boolean hasNext(){
            if (index < names.length) {
                return true;
            }
            return false;
        }
        @Override
        public Object next() {
            if (this.hasNext()) {
                return names[index++];
            }
            return null;
        }
    }
}

使用NameRepository来获取迭代器，并打印名字

public class IteratorPatternDemo {
    public static void main(String[] args) {
        NameRepository nameRepository = new NameRepository();

        for (Iterator iter = nameRepository.getIterator(); iter.hasNext();) {
            String name = (String)iter.next();
            System.out.println("Name: "+name);
        }
    }
}

Python 实现

对于python来说，有内建函数next()，以及原生的Iterable对象：tuple、list、dict。

对于python的迭代器来说，最简单的实现方式就是使用yield。并且，对于python来说，使用上述的hasNext()并不够优雅。使用yield关键字实现的迭代器，在迭代结束后会抛出一个StopIteration异常，并不需要一直检查hasNext()。

不过为了严谨，还是实现一次上述代码吧。

import abc

class Iterator(abc.ABC):
    @abc.abstractmethod
    def has_next(self) -> bool: ...

    @abc.abstractmethod
    def next(self) -> object: ...

class Container(abc.ABC):
    @abc.abstractmethod
    def get_iterator(self) -> Iterator: ...

class NameRepository(Container):
    def get_iterator(self):
        names = ["Robert", "John", "Julie", "Lora"]

        class NameIterator(Iterator):
            def __init__(self):
                self.index = 0

            def has_next(self):
                return self.index < len(names)

            def next(self):
                if self.has_next():
                    self.index += 1
                    return names[self.index - 1]
                return None

        return NameIterator()

if __name__ == "__main__":
    name_repository = NameRepository()
    name_iterator = name_repository.get_iterator()
    while name_iterator.has_next():
        print(f"Name: {name_iterator.next()}")

更优雅的Python实现版本

实际上，这一版本也仅仅是上一版本的略微优化。为了实现与上面一致的next()和has_next()而使得代码显得比较啰嗦

注：这里是用到了python的语法糖，返回值的关键字是yield。因此想要返回什么值，或者在返回之前做处理，可以在yield之前执行。

class NameRepository(object):
    def __init__(self):
        self.names = ["Robert", "John", "Julie", "Lora"]
        self.index = 0
        self._iterator = self.__iterator__()

    def __iterator__(self):
        for i in range(len(self.names)):
            self.index = i
            yield self.names[i]

    def __next__(self):
        return next(self._iterator)

    def next(self):
        return next(self)

    def has_next(self):
        return self.index < len(self.names) - 1

if __name__ == '__main__':
    name_repository = NameRepository()
    while name_repository.has_next():
        print(f"Name: {name_repository.next()}")

简化的版本

class NameRepository(object):
    def __init__(self):
        self.names = ["Robert", "John", "Julie", "Lora"]
        self._iterator = self.__iterator__()

    def __iterator__(self):
        for i in range(len(self.names)):
            yield self.names[i]

    def __next__(self):
        return next(self._iterator)

    def __iter__(self):
        return self

if __name__ == '__main__':
    name_repository = NameRepository()
    while True:
        try:
            print(f"Name: {next(name_repository)}")
        except StopIteration:
            break
    # 或者
    for name in NameRepository():
        print(f"Name: {name}")

更简化的版本

class NameRepository(object):
    def get_iterator(self):
        names = ["Robert", "John", "Julie", "Lora"]

        def iterator():
            for name in names:
                yield name

        return iterator()

if __name__ == '__main__':
    name_iterator = NameRepository().get_iterator()
    while True:
        try:
            print(f"Name: {next(name_iterator)}")
        except StopIteration:
            break
    # 或者
    for name in NameRepository().get_iterator():
        print(f"Name: {name}")
    # 过程
    name_iterator = NameRepository().get_iterator()
    print(next(name_iterator))
    print(next(name_iterator))
    print(next(name_iterator))
    print(next(name_iterator))
    print(next(name_iterator))  # Raise StopIteration