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

最新推荐文章于 2024-08-23 11:07:43 发布
最新推荐文章于 2024-08-23 11:07:43 发布
阅读量229 收藏
点赞数
分类专栏： 设计模式大全 文章标签： 设计模式 迭代器模式 python java golang c++ javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuang/article/details/133694157
版权

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)

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

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

4. 实现要素

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

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

5. UML图

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

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

在这个 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<T> {
    boolean hasNext();
    T next();
}

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

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

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

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

    private class BookIterator implements Iterator<T> {
        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<Book> bookstore = new BookStore<>();

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

        Iterator<Book> iterator = bookstore.createIterator();

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

在这个示例中，我们定义了迭代器接口 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)
        }
}

在这个示例中，我们定义了 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());
}

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

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

6.4 C++实现

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

#include <iostream>
#include <vector>

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

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

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

public:
    BookIterator(std::vector<T>& 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 <typename T>
class BookStore : public Aggregate<T> {
private:
    std::vector<T> books;

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

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

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

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

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

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

    Iterator<Book>* 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;
}

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

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

7. 练习题

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

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

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

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

guohuang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
设计模式——迭代器模式
姑娘眼中的明月色，就只有你一人，轻轻望去，才能发现。
06-08 2346
迭代器模式（Iterator Pattern）定义：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标（Cursor）。迭代器模式是一种对象行为型模式。 英文定义：“Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.”...
详解Java设计模式——迭代器模式
08-26
详解Java设计模式——迭代器模式 迭代器模式是Java设计模式的一种，主要用于解决聚合对象的遍历问题。该模式提供了一种方法顺序访问一个聚合对象中的各个元素，而又无须暴露该对象的内部表示。通过使用迭代器模式，...
大话设计模式——24.迭代器模式（Iterator Pattern）
a1498665771的博客
04-10 722
提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部实现。（Java中使用最多的设计模式之一）优点可以不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据支持以不同的方式遍历一个聚合对象缺点对于比较简单的遍历如数组、有序列表，该方式实现比较繁琐在遍历的同时更改迭代器所在的集合结构会导致异常。
Java 设计模式——迭代器模式
代码星辰的博客
07-15 2030
本文介绍了迭代器模式的相关知识。
设计模式第16讲——迭代器模式（Iterator）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-25 6895
迭代器模式是一种行为型设计模式。一、什么是迭代器模式 二、角色组成 三、 优缺点 四、应用场景 4.1 生活场景 4.2 java场景 五、代码实现5.0 UML类图 5.1 Student——学生实体类5.2 StudentIterator——抽象迭代器（Iterator）5.3 StudentListIterator——具体迭代器（Concrete iterator）5.4 StudentAggregate——抽象聚合器（Aggregate）5.5 ClassList
js设计模式——4.迭代器模式
weixin_33698823的博客
04-17 78
js设计模式——4.迭代器模式 代码演示 /*js设计模式——迭代器模式*/ class Iterator { constructor(container) { this.list = container.list; this.index = 0; } // next 判断下一项还有则继续追加 ...
C++设计模式(20)——迭代器模式
伍粟的博客
02-25 1389
C++ 迭代器模式
JavaScript设计模式——迭代器模式
前端御书房
08-22 316
javascript设计模式，迭代器模式，持续更新中……
设计模式——迭代器模式（附代码示例）
枫陵的博客
05-25 4732
一. 传统方式 以学校院系展示为例，实现在一个页面展示学校的院系组成，一个学校有多个学院，一个学院有多个系。传统方式实现类图如下： 传统方式将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。实际上我们的要求是在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，而每个院对于系的存储方式各不相同（如数组、集合等），因此这种...
设计模式行为型——迭代器模式
tszc95的博客
08-03 693
迭代器模式（Iterator Pattern）属于行为型模式，其提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示，即不需要知道集合对象的底层表示。编程环境中非常常用的设计模式。
Java23种设计模式——20.行为型模式之迭代器模式
胖子胖子大胖子的博客
11-14 948
Java中除去有设计原则之外，还有23中设计模式。 这些模式都是前辈们一点一点积累下来，一直在改进，一直在优化的，而这些设计模式可以解决一些特定的问题。 并且在这些模式中，可以说是将语言的使用体现的淋漓尽致。 那我们今天要学习行为型模式中的迭代器模式 ！ 迭代器模式 先来百科一下，什么是迭代器模式 这个其实和我们在遍历 List、Set集合时候使用的迭代器类似，我们在不暴露对象的内部，就可以遍历该集合 模式的定义与特点 迭代器（Iterator）模式的定义：提供一个对象来顺...
设计模式——JAVA.docx
04-03
- **行为型模式**（共11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 每一种设计模式都有其特定的应用场景和解决的...
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
设计模式(十七)——迭代器模式(Iterator Pattern)
12-21
迭代器模式(Iterator Pattern) 基本介绍 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。 提供一种可以遍历聚合对象的方式。又...
Android编程设计模式之迭代器模式详解
08-28
迭代器模式是指在客户访问类与容器体之间插入了一个第三者——迭代器，以解决容器类承担了过多的功能和遍历状态的存储问题。迭代器模式可以让容器类专注于维护自身内部的数据元素，而将遍历的方法封装在迭代器中，...
设计模式 5 原型模式
小小程序猿
08-23 521
原型模式允许一个对象通过复制自身来创建新的对象。这种模式提供了一种创建对象的快捷方式，尤其适用于创建代价较高的对象。
设计模式六大原则：迪米特法则详细说明和案例示范
weixin_39996520的博客
08-20 571
只与直接的朋友通信：一个对象应当只与那些与它关系密切的对象直接通信，而不应该依赖于太多的其他对象。避免过度依赖：对象之间的依赖关系应该尽量减少，避免形成复杂的依赖链。在实际开发中，这意味着我们应该设计简洁的接口，避免对象过度依赖于其他对象的内部细节，从而减少对象之间的耦合度。迪米特法则强调对象之间的交互应尽可能少，避免产生复杂的依赖关系。通过引入中介类或封装层，可以将依赖关系控制在合理的范围内，减少类之间的耦合度，提高系统的可维护性和可扩展性。
二十三设计模式速记
最新发布
慢慢
08-23 317
Java设计模式通常被分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。每种类型包含若干种具体的设计模式。创建型模式（Creational Patterns）：结构型模式（Structural Patterns）：行为型模式（Behavioral Patterns）：
设计模式六大原则之一的接口隔离原则
jun778895的博客
08-20 1260
接口隔离原则的定义是：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。换句话说，接口的设计应当尽量细化，每个接口只包含客户端需要的方法，而不是将所有可能的方法都放在一个接口中。接口隔离原则是面向对象设计中的一个重要原则，它强调了接口的设计应当尽量保持简洁和专一。通过细化接口、减少依赖和提高复用性等方式，接口隔离原则有助于降低系统的复杂性、提高系统的灵活性和可维护性。然而，在应用接口隔离原则时，也需要注意避免过度细化接口和增加系统的复杂性。
Java设计模式：行为型模式——迭代器模式详解
"JAVA-设计模式-行为型模式-迭代器模式" 迭代器模式是一种行为设计模式，它允许我们顺序访问聚合对象的元素，而无需暴露其内部结构。这种模式将遍历任务从聚合对象转移到专门的迭代器对象，使得聚合类能够专注于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

guohuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值