• 设计模式——16. 迭代器模式

    1. 说明

    迭代器模式（Iterator Pattern）是一种行为型设计模式，它用于提供一种访问聚合对象（如列表、数组、集合等）元素的统一接口，而不需要了解底层数据结构的具体实现。迭代器模式将遍历聚合对象的操作封装在一个独立的迭代器对象中，这样可以隔离遍历算法和数据结构，使得代码更加灵活、可维护和可扩展。
    迭代器模式通常包含以下角色：

    1. 迭代器（Iterator）：定义了遍历聚合对象元素的接口，包括获取下一个元素、判断是否还有元素等方法。
    2. 具体迭代器（Concrete Iterator）：实现了迭代器接口，在具体聚合对象上进行遍历操作。
    3. 聚合对象（Aggregate）：定义了创建迭代器对象的接口，通常包括一个或多个方法来获取迭代器。
    4. 具体聚合对象（Concrete Aggregate）：实现了聚合对象接口，提供了创建具体迭代器对象的方法。

    使用迭代器模式可以让客户端代码遍历聚合对象的元素而不需要了解其内部结构，这增强了代码的可维护性和可扩展性。此外，迭代器模式还可以让不同类型的聚合对象共享通用的迭代器，从而提高了代码的复用性。

    迭代器模式在编程中广泛应用，特别是在处理集合类数据结构时，例如在编程语言中的容器类、数据库查询结果集、文件系统的目录遍历等场景。

    2. 使用的场景

    迭代器模式的使用场景通常包括以下情况：

    1. 遍历聚合对象：当需要遍历访问聚合对象（如列表、数组、集合、树结构等）中的元素，并希望将遍历操作抽象出来，使得代码更加模块化和可维护时，可以使用迭代器模式。
    2. 隐藏数据结构的具体实现：迭代器模式可以将数据结构的具体实现细节隐藏在迭代器内部，使客户端代码不依赖于特定的数据结构。
    3. 支持多种遍历方式：某些数据结构可能支持多种遍历方式，例如前向、后向、深度优先、广度优先等，使用迭代器模式可以为每种遍历方式创建不同的迭代器。
    4. 提供统一的访问接口：通过迭代器模式，可以为不同类型的聚合对象提供统一的访问接口，使得客户端代码更加通用。
    5. 分离聚合对象与遍历算法：迭代器模式将聚合对象的数据和遍历算法分离开来，使得它们可以独立变化，从而更容易维护和扩展。
    6. 支持延迟加载：在某些情况下，迭代器模式可以支持延迟加载数据，只在需要时才加载数据，以节省资源。
    7. 适配不同数据源：当需要适配不同数据源或数据格式时，迭代器模式可以将数据源的访问方式统一，使得客户端代码不必关心数据源的具体细节。

    总之，迭代器模式在需要遍历访问聚合对象元素，并且希望将遍历操作抽象出来的情况下，非常有用。它提供了一种标准的方式来遍历各种不同类型的聚合对象，从而增加了代码的灵活性和可扩展性。

    3. Python应用例子

    以下是一个使用 Python 实现的迭代器模式的示例，其中我们模拟了一个简单的书店库存管理系统：

    # 迭代器接口
class Iterator:
    def __init__(self, collection):
        self._collection = collection
        self._index = 0

    def has_next(self):
        return self._index < len(self._collection)

    def next(self):
        if self.has_next():
            item = self._collection[self._index]
            self._index += 1
            return item
        else:
            raise StopIteration()


# 聚合接口
class Aggregate:
    def create_iterator(self):
        pass


# 具体聚合类
class BookStore(Aggregate):
    def __init__(self):
        self._books = []

    def add_book(self, book):
        self._books.append(book)

    def create_iterator(self):
        return Iterator(self._books)


# 具体元素类
class Book:
    def __init__(self, title):
        self._title = title

    def __str__(self):
        return self._title


# 客户端代码
if __name__ == "__main__":
    bookstore = BookStore()
    bookstore.add_book(Book("Book 1"))
    bookstore.add_book(Book("Book 2"))
    bookstore.add_book(Book("Book 3"))

    iterator = bookstore.create_iterator()

    print("Books in the bookstore:")
    while iterator.has_next():
        book = iterator.next()
        print(book)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58

    在这个示例中，我们定义了一个迭代器接口 Iterator，其中包括 has_next 和 next 方法。然后，我们创建了一个具体聚合类 BookStore，它实现了 Aggregate 接口，提供了 create_iterator 方法来创建迭代器。Book 类表示书籍对象，客户端代码通过迭代器遍历书店库存中的书籍。

    运行示例代码会输出库存中的书籍列表。这个示例演示了如何使用迭代器模式来遍历聚合对象的元素，使得客户端代码不需要了解底层数据结构的实现细节。

    4. 实现要素

    迭代器模式的实现要素包括以下关键部分：

    1. 迭代器接口（Iterator）：定义了迭代器对象的接口，通常包括获取下一个元素、判断是否还有元素等方法。这个接口将遍历聚合对象的操作抽象化。
    2. 具体迭代器（Concrete Iterator）：实现了迭代器接口，负责在具体聚合对象上进行遍历操作。它追踪当前遍历的位置，提供访问元素的方法。
    3. 聚合接口（Aggregate）：定义了创建迭代器对象的接口，通常包括一个或多个方法来获取迭代器。这个接口可以是抽象的。
    4. 具体聚合类（Concrete Aggregate）：实现了聚合接口，提供了创建具体迭代器对象的方法。它包含了要被遍历的元素。

    5. UML图

    下面是迭代器模式的典型 UML 类图：

                        +-------------------+
                    |   <>   |
                    |     Iterator      |
                    +-------------------+
                    | +next(): Element  |
                    | +hasNext(): bool  |
                    +-------------------+
                            ^
                            |
                            |
                            |
+-------------------+       |       +-------------------+
|    <>  |       |       |   <>   |
|    Aggregate      |       |       |     Element       |
+-------------------+       |       +-------------------+
| +createIterator():|       |       |                   |
|   Iterator        |-------|       |                   |
+-------------------+       |       +-------------------+
                            |
                            |
                            |
                    +-------------------+
                    | ConcreteAggregate |
                    +-------------------+
                    | +createIterator() |
                    +-------------------+
                    |                   |
                    |                   |
                    +-------------------+

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    在这个 UML 图中，迭代器模式包括了四个主要部分：Iterator 接口、Element 接口、Aggregate 接口以及具体的聚合类 ConcreteAggregate。

    • Iterator 接口定义了迭代器的方法，包括 next 用于获取下一个元素，以及 hasNext 用于判断是否还有元素。
    • Element 接口表示聚合对象的元素，这是一个可选的部分，根据需要定义。
    • Aggregate 接口定义了创建迭代器对象的方法，通常包括一个 createIterator 方法。
    • ConcreteAggregate 是具体的聚合类，实现了 Aggregate 接口，并提供了创建具体迭代器对象的方法。这个类包含了要被遍历的元素。

    具体迭代器类（Concrete Iterator）和具体元素类（Concrete Element）也可以存在，根据需要来扩展。迭代器模式的核心思想是将遍历操作从聚合对象中分离出来，使得聚合对象和遍历算法可以独立变化。

    6. Java/golang/javascrip/C++ 等语言实现方式

    6.1 Java实现

    上述例子用Java语言实现示例如下：

    import java.util.ArrayList;
import java.util.List;

// 迭代器接口
interface Iterator {
    boolean hasNext();
    T next();
}

// 聚合接口
interface Aggregate {
    Iterator createIterator();
}

// 具体聚合类
class BookStore implements Aggregate {
    private List books = new ArrayList<>();

    public void addBook(T book) {
        books.add(book);
    }

    @Override
    public Iterator createIterator() {
        return new BookIterator();
    }

    private class BookIterator implements Iterator {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < books.size();
        }

        @Override
        public T next() {
            if (hasNext()) {
                return books.get(index++);
            } else {
                throw new IndexOutOfBoundsException();
            }
        }
    }
}

// 具体元素类
class Book {
    private String title;

    public Book(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        return title;
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        BookStore bookstore = new BookStore<>();

        bookstore.addBook(new Book("Book 1"));
        bookstore.addBook(new Book("Book 2"));
        bookstore.addBook(new Book("Book 3"));

        Iterator iterator = bookstore.createIterator();

        System.out.println("Books in the bookstore:");
        while (iterator.hasNext()) {
            Book book = iterator.next();
            System.out.println(book);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78

    在这个示例中，我们定义了迭代器接口 Iterator，包括 hasNext 和 next 方法。Aggregate 接口定义了 createIterator 方法，表示创建迭代器。BookStore 是具体的聚合类，负责管理书籍。BookIterator 是具体迭代器类，用于遍历书籍列表。

    客户端代码创建了一个书店对象，添加了几本书，然后使用迭代器遍历书店库存中的书籍。这个示例演示了如何在 Java 中实现迭代器模式来遍历聚合对象的元素。

    6.2 Golang实现

    上述例子用golang实现示例如下：

    package main

import (
        "fmt"
)

// Iterator 接口定义了迭代器的方法
type Iterator interface {
        HasNext() bool
        Next() interface{}
}

// Aggregate 接口定义了创建迭代器的方法
type Aggregate interface {
        CreateIterator() Iterator
}

// BookStore 表示具体聚合类
type BookStore struct {
        books []interface{}
}

// AddBook 添加书籍到书店库存
func (b *BookStore) AddBook(book interface{}) {
        b.books = append(b.books, book)
}

// CreateIterator 创建具体迭代器对象
func (b *BookStore) CreateIterator() Iterator {
        return &BookIterator{
                books: b.books,
                index: 0,
        }
}

// BookIterator 表示具体迭代器类
type BookIterator struct {
        books []interface{}
        index int
}

// HasNext 判断是否还有下一本书
func (b *BookIterator) HasNext() bool {
        return b.index < len(b.books)
}

// Next 获取下一本书
func (b *BookIterator) Next() interface{} {
        if b.HasNext() {
                book := b.books[b.index]
                b.index++
                return book
        }
        return nil
}

// Book 表示具体元素类
type Book struct {
        title string
}

// NewBook 创建新书
func NewBook(title string) *Book {
        return &Book{title: title}
}

func main() {
        bookstore := &BookStore{}
        bookstore.AddBook(NewBook("Book 1"))
        bookstore.AddBook(NewBook("Book 2"))
        bookstore.AddBook(NewBook("Book 3"))

        iterator := bookstore.CreateIterator()

        fmt.Println("Books in the bookstore:")
        for iterator.HasNext() {
                book := iterator.Next().(*Book)
                fmt.Println(book.title)
        }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80

    在这个示例中，我们定义了 Iterator 接口，包括 HasNext 和 Next 方法，以及 Aggregate 接口，包括 CreateIterator 方法。BookStore 是具体聚合类，负责管理书籍。BookIterator 是具体迭代器类，用于遍历书籍列表。Book 表示具体元素类。

    客户端代码创建了一个书店对象，添加了几本书，然后使用迭代器遍历书店库存中的书籍。这个示例演示了如何在 Go 中实现迭代器模式来遍历聚合对象的元素。

    6.3 Javascript实现

    上述例子用javascript实现示例如下：

    // 迭代器接口
class Iterator {
  constructor(collection) {
    this.collection = collection;
    this.index = 0;
  }

  hasNext() {
    return this.index < this.collection.length;
  }

  next() {
    if (this.hasNext()) {
      const item = this.collection[this.index];
      this.index++;
      return item;
    } else {
      throw new Error('No more items');
    }
  }
}

// 聚合接口
class Aggregate {
  createIterator() {}
}

// 具体聚合类
class BookStore extends Aggregate {
  constructor() {
    super();
    this.books = [];
  }

  addBook(book) {
    this.books.push(book);
  }

  createIterator() {
    return new Iterator(this.books);
  }
}

// 具体元素类
class Book {
  constructor(title) {
    this.title = title;
  }

  toString() {
    return this.title;
  }
}

// 客户端代码
const bookstore = new BookStore();

bookstore.addBook(new Book('Book 1'));
bookstore.addBook(new Book('Book 2'));
bookstore.addBook(new Book('Book 3'));

const iterator = bookstore.createIterator();

console.log('Books in the bookstore:');
while (iterator.hasNext()) {
  const book = iterator.next();
  console.log(book.toString());
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    在这个示例中，我们定义了迭代器类 Iterator，包括 hasNext 和 next 方法。Aggregate 类定义了 createIterator 方法，用于创建迭代器。BookStore 类是具体的聚合类，负责管理书籍。Book 类表示具体元素。

    客户端代码创建了一个书店对象，添加了几本书，然后使用迭代器遍历书店库存中的书籍。这个示例演示了如何在 JavaScript 中实现迭代器模式来遍历聚合对象的元素。

    6.4 C++实现

    上述例子用C++实现如下：

    #include 
#include 

// 迭代器接口
template 
class Iterator {
public:
    virtual bool hasNext() = 0;
    virtual T next() = 0;
};

// 聚合接口
template 
class Aggregate {
public:
    virtual Iterator* createIterator() = 0;
};

// 具体迭代器类
template 
class BookIterator : public Iterator {
private:
    std::vector collection;
    size_t index;

public:
    BookIterator(std::vector& coll) : collection(coll), index(0) {}

    bool hasNext() override {
        return index < collection.size();
    }

    T next() override {
        if (hasNext()) {
            return collection[index++];
        } else {
            throw std::out_of_range("No more items");
        }
    }
};

// 具体聚合类
template 
class BookStore : public Aggregate {
private:
    std::vector books;

public:
    void addBook(const T& book) {
        books.push_back(book);
    }

    Iterator* createIterator() override {
        return new BookIterator(books);
    }
};

// 具体元素类
class Book {
private:
    std::string title;

public:
    Book(const std::string& t) : title(t) {}

    std::string toString() const {
        return title;
    }
};

int main() {
    BookStore bookstore;
    bookstore.addBook(Book("Book 1"));
    bookstore.addBook(Book("Book 2"));
    bookstore.addBook(Book("Book 3"));

    Iterator* iterator = bookstore.createIterator();

    std::cout << "Books in the bookstore:" << std::endl;
    while (iterator->hasNext()) {
        Book book = iterator->next();
        std::cout << book.toString() << std::endl;
    }

    delete iterator;

    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88

    在这个示例中，我们使用了 C++ 的模板类和继承来实现迭代器模式。迭代器类 Iterator 包括 hasNext 和 next 方法。聚合类 Aggregate 包括 createIterator 方法，用于创建迭代器。具体迭代器类 BookIterator 和具体聚合类 BookStore 分别用于遍历书籍和管理书店库存。Book 类表示具体元素。

    客户端代码创建了一个书店对象，添加了几本书，然后使用迭代器遍历书店库存中的书籍。这个示例演示了如何在 C++ 中实现迭代器模式来遍历聚合对象的元素。

    7. 练习题

    请编写一个简单的集合类（例如，可以表示整数集合的类）和一个迭代器，使得可以遍历该集合类中的元素。

    要求：
    集合类应该支持以下操作：

    1. add(item)：将一个元素添加到集合中。
    2. size()：返回集合中元素的数量。
    3. get(index)：根据索引返回集合中的元素。
      编写一个迭代器类，使得可以使用迭代器遍历集合中的元素。迭代器类应该支持以下操作：
    4. hasNext()：检查是否还有下一个元素。
    5. next()：返回下一个元素。
      在编写完集合类和迭代器类后，编写一个程序来演示如何使用它们来创建一个集合、添加元素、遍历元素。

    你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

  • 相关阅读:
    CDN：加速型与高防型的不同
    P1147 连续自然数和 【双指针（尺取法）】
    猿创征文｜vue中使用Axios最佳实践
    JavaScript系列之数据类型
    Matlab数字图像处理 03 空域滤波（滤波器、线性滤波器、统计排序滤波器、图像平滑、锐化）
    hexo踩坑之点击页面跳转变下载文件
    03excel函数2
    Mahony 滤波算法参数自动调节方法 11
    stm32应用、项目、调试
    Express 2 快速入门 - HelloWorld
  • 原文地址：https://blog.csdn.net/guohuang/article/details/133694157