【项目实战】设计模式之迭代子模式，Iterator 结构

我就是我 2024-03-25 20:55 103阅读 0赞

## 一、迭代子模式是什么？ ##

迭代子模式是一种设计模式  
迭代子模式是一种对象的行为模式

迭代子模式，用于遍历一组类或对象，并对其中的每一个进行操作。  
迭代子模式，可以顺序访问一个聚集中的元素，而不必暴露聚集的内部表象。  
迭代子模式，将【迭代逻辑 】封装到一个【独立的子对象 】中，从而与聚集本身隔开。

*  聚集：多个对象聚在一起形成的总体。
 *  聚集对象：能够包容一组对象的容器对象。

迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。

## 二、迭代子模式的两种实现方式 ##

迭代子模式有以下两种实现方式：

### 2.1 白箱聚集与外禀迭代子 ###

如果聚集对象为所有对象提供同一个接口，也就是宽接口的话，会满足迭代子模式对迭代子对象的要求，但是会破坏对聚集对象的封装。

### 2.2 黑箱聚集与内禀迭代子 ###

由于迭代子是在聚集结构之外的，因此这样的迭代子又叫做外禀迭代子。

## 三、迭代子模式的主要作用 ##

*  将遍历对象的过程封装起来，使得代码更加简洁和可读性更好。
 *  遍历各种类型的集合，提高代码的可读性和可维护性。
 *  将迭代逻辑封装到一个独立的迭代子对象中，从而与聚集本身分割开，更符合开闭原则。
 *  统一了所有的集合对象的迭代遍历接口，可以使得系统使用一个统一的方式对多个不同的集合对象进行迭代。

## 四、迭代子模式中的几个角色 ##

迭代子模式通常包含以下几个角色：

*  抽象迭代器：定义一个接口，用于实现对集合中元素的遍历操作。
 *  具体迭代器：实现抽象迭代器接口，用于具体实现对集合中元素的遍历操作。
 *  集合：包含一组元素，需要被遍历。
 *  具体集合：实现集合接口，用于具体实现集合中元素的存储和访问。

## 五、迭代子模式示例和应用场景 ##

十分的常见！

### 5.1 Java中的代码：Iterator 类 ###

以下是一个简单的迭代子模式示例：

#### 5.1.1 抽象迭代器 ####

可以定义一个抽象迭代器接口，用于实现对集合中元素的遍历操作。  
以下是一个简单的抽象迭代器接口示例：

public interface Iterator<T> {
        
        boolean hasNext();
        T next();
    }

在上述代码中，定义了一个Iterator接口，其中包含了两个方法：hasNext()和next()。hasNext()方法用于判断集合中是否还有元素可以遍历  
next()方法用于获取下一个元素。

#### 5.1.2 具体迭代器 ####

可以实现抽象迭代器接口，用于具体实现对集合中元素的遍历操作。  
以下是一个简单的具体迭代器示例：

public class ListIterator<T> implements Iterator<T> {
        
        private List<T> list;
        private int index;
        public ListIterator(List<T> list) {
        
            this.list = list;
            this.index = 0;
        }
        @Override
        public boolean hasNext() {
        
            return index < list.size();
        }
        @Override
        public T next() {
        
            return list.get(index++);
        }
    }

在上述代码中，实现了一个ListIterator类，用于遍历List集合中的元素。  
其中，使用了list和index两个成员变量来存储集合和当前遍历的元素索引。  
在hasNext()方法中，判断index是否小于集合的size()，如果是，则说明集合中还有元素可以遍历；  
在next()方法中，返回list.get(index++)获取下一个元素。

#### 5.1.3 集合 ####

可以定义一个集合类，用于存储一组元素。以下是一个简单的集合类示例：

public class List<T> {
        
        private List<T> list = new ArrayList<>();
        public void add(T element) {
        
            list.add(element);
        }
        public T get(int index) {
        
            return list.get(index);
        }
        public int size() {
        
            return list.size();
        }
    }

在上述代码中，实现了一个List类，用于存储一组元素。  
其中，使用了ArrayList作为底层存储结构，提供了add()、get()和size()等方法来实现对元素的存储和访问。

#### 5.1.4 具体集合 ####

可以实现集合接口，用于具体实现集合中元素的存储和访问。  
以下是一个简单的具体集合类示例：

public class UserList implements List<User> {
        
        private List<User> userList = new ArrayList<>();
        @Override
        public void add(User element) {
        
            userList.add(element);
        }
        @Override
        public User get(int index) {
        
            return userList.get(index);
        }
        @Override
        public int size() {
        
            return userList.size();
        }
     }

在上述代码中，实现了一个UserList类，用于存储一组User对象。  
其中，实现了List接口中的add()、get()和size()等方法，用于实现对元素的存储和访问。

#### 5.1.5 应用：遍历 Collection中物件 ####

public class TestCommand {
        
    　public static void main(String[] args) {
        
    　List queue = Producer.produceRequests();
    　　　　  for (Iterator it = queue.iterator(); it.hasNext(); )
    　　　　　　　　 //取出List 中东东,其它特征都不能确定 ,只能保证一个特征是100%正确 ,
    　　　　　　　　 // 他们至少是接口Command的 "儿子" 。所以强制转换类别型为界面
              Command ((Command)it.next()).execute();
     }
    }

### 5.2 C++ STL中的 iterator ###

> C++ STL里面的 iterator迭代器使用“++”运算符进行访问。

C++ STL（Standard Template Library）中的迭代器使用“++”运算符进行访问。迭代器是一种用于遍历容器（如向量、列表、集合等）中元素的对象。它们提供了一种方便的方式来遍历容器中的元素。

在C++ STL中，iterator是一种访问容器中元素的迭代器，可以使用++操作符来遍历容器中的元素。++操作符会将迭代器指向下一个元素，如果已经到达了容器的末尾，则会将迭代器重置为容器的起始位置。

在C++ STL中，迭代器可以通过使用“++”运算符来递增，从而访问下一个元素。

#### 5.2.1 实例代码1 ####

例如，如果有一个名为“my\_vector”的向量，可以使用以下方式来遍历其中的元素：

std::vector<int> my_vector = {
        1, 2, 3, 4, 5};
    std::vector<int>::iterator iter = my_vector.begin();
    
    while (iter != my_vector.end()) {
        
        std::cout << *iter << std::endl;
        ++iter;
    }

在上面的代码中，首先创建了一个名为“iter”的迭代器，并将其初始化为向量的起始位置。然后，在循环中，使用“\*”运算符来获取迭代器当前指向的元素，并使用“++”运算符将迭代器递增到下一个元素。循环将一直执行，直到迭代器到达向量的末尾。

需要注意的是，迭代器不仅可以用于访问容器中的元素，还可以用于修改它们。例如，我们可以使用“\*”运算符来修改迭代器当前指向的元素的值。

#### 5.2.2 实例代码2 ####

#include <iostream>
    #include <vector>
    
    using namespace std;
    
    int main() {
        
        vector<int> vec{
        1, 2, 3, 4, 5};
    
        // 使用迭代器遍历容器
        auto it = vec.begin();
        while(it != vec.end()) {
        
            cout << *it << " ";
            it++;
        }
    
        cout << endl;
    
        // 使用++操作符遍历容器
        it = vec.begin();
        while(it != vec.end()) {
        
            cout << *it << " ";
            it++;
        }
    
        cout << endl;
    
        return 0;
    }

在上述代码中，首先定义了一个vector容器，然后使用迭代器遍历容器中的元素。在while循环中，使用迭代器的指针移动到下一个元素，并输出该元素的值。最后，使用++操作符来遍历容器中的元素，输出各个元素的值。

输出结果为：

1 2 3 4 5 
    1 2 3 4 5

可以看到，使用++操作符和使用迭代器的指针移动到下一个元素的效果是一样的。