设计模式之16 - 迭代器模式Itertor

最新推荐文章于 2023-08-03 18:06:30 发布
最新推荐文章于 2023-08-03 18:06:30 发布
阅读量1.7k 收藏 1
点赞数 5
分类专栏： C++ | 设计模式 文章标签： C++ 设计模式 迭代器模式 Iterator Iterator模式

1. 迭代器模式（Iterator Pattern）的定义

（1）定义：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

　　①迭代器迭代的是具体的聚合对象（如数组和链表等），它围绕的是“访问”做文章。

　　②可用不同的遍历策略来遍历聚合，比如是否需要过滤

　　③为不同聚合结构提供统一的迭代接口，也就是说通过一个迭代接口可以访问不同的聚合结构，这叫做多态迭代。标准的迭代模式实现基本上都是支持多态迭代的。如用同一个迭代接口来实现对数组和链表的遍历。

（2）迭代器模式的结构和说明

 

　　①Iterator：迭代器接口。定义访问和遍历元素的接口。

　　②ConcreteInterator：具体的迭代器实现对象，会持有被迭代的具体的聚合对象的引用，并对聚合对象的遍历及跟踪遍历时的当前位置。

　　③Aggregate：聚合对象。提供创建相应迭代器对象的函数（如createIterator()）。

　　④ConcreteAggregate：具体聚合对象。实现创建相应迭代器对象。

【编程实验】以统一的方式对数组和链表进行遍历（多态迭代）

  View Code

2. 思考迭代器模式

（1）迭代器的本质：控制访问聚合对象中的元素。迭代器能实现“无须暴露聚合对象的内部实现，就能够访问到聚合对象的各个元素的功能”，做到“透明”的访问聚合对象中的元素。注意迭代器能够即“透明”访问，又可以“控制访问”聚合对象，认识这点，对于识别和变形使用迭代器模式很有帮助。

（2）迭代器的关键思想：把对聚合对象的遍历访问从聚合对象中分离出来，放入单独的迭代器中，这样聚合对象会变得简单，而且迭代器和聚合对象可以独立地变化和发展，会大大加强系统的灵活性。

（3）迭代器的动机：

　　在软件构建过程中，集合对象内部结构常常变化各异。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明地访问其中包含的元素；同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。将遍历机制抽象为“迭代器对象”为“应对变化中的集合对象”提供了一种优雅的方法

（4）内部迭代器与外部迭代器

　　①内部迭代器：指的是由迭代器自己来控制下一个元素的步骤，即当客户端利用迭代器读取当前元素后，迭代器的当前元素自动移到一下个元素，而客户端无法干预。

　　②外部迭代器：则客户端控制迭代下一个元素的步骤，即客户端必须显示的next来迭代下一个元素。从总体来说外部迭代器比内部迭代器要灵活一些。这也是常见的实现方式。

【编程实验】简单模仿STL库容器类的遍历方式（变式迭代器）

复制代码 
//行为模式——迭代器模式
//场景：简单仿STL容器类的Iterator
//说明：该模式主要用于将列表的访问和遍历分离出来并放进一个迭代器中，
//本例是模仿STL库的容量遍历方式
#include <iostream>
#include <string>

using namespace std;

class ArrayList
{
private:
    int cnt;
    int arr[100];

public:
    typedef int* Iterator; //内部类（型）

    ArrayList(){cnt = 0;}

    //这里可以看出来Iterator声明为一个Int*类型的指针
    Iterator begin()
    {
        return &arr[0];
    }

    Iterator end()
    {
        return &arr[cnt];
    }

    void insert(int v)
    {
        if(cnt>=100)
        {
            cout << "列表容量己满，不可再插入" << endl;
            return;
        }
        arr[cnt++] = v;
    }
};
int main()
{
    ArrayList al;

    for(int i = 0; i< 110; i++)
    {
        al.insert(i);
    }

    ArrayList::Iterator iter = al.begin();
    while( iter != al.end())
    {
        cout << *iter << endl;
        ++iter;
    }

    return 0;
}
复制代码

3. 迭代器模式高级应用

（1）带迭代策略的迭代器

　　①由于迭代器模式把聚合对象和访问聚合的机制实现了分离，因此可以在迭代器上实现不同的迭代策略，如实现过滤功能的迭代器

　　②在实现过滤功能的迭代器中，有两种常见的过滤情况，一是对数据整条过滤，如只能查看自己部门的数据；另一种情况是对数据进行部分过滤，如某些人不能查看工资数据。

　　③带迭代策略的迭代器实现的一个基本思路就是把聚合对象的聚合数据获取到并存储在迭代器中，这样迭代器就可以按照不同的策略来迭代数据了。

（2）双向迭代器：可以向前和向后遍历数据的迭代器

 【编程实验】带过滤和双向遍历功能的工资查看系统

复制代码 
//行为模式——迭代器模式
//场景：工资表数据遍历(带过滤和双向遍历功能)

#include <iostream>
#include <string>
#include <vector>

using namespace std;
//***************************辅助类*************************
//前向声明
class Iterator;
class SalaryModel;
typedef SalaryModel Object;

//工资描述模型对象
class SalaryModel
{
private:
    string userName; //职工姓名
    double salary;      //工资数额
public:
    string& getUserName(){return userName;}
    void setUserName(string name)
    {
        this->userName = name;
    }

    double getSalary(){return salary;}
    void setSalary(double salary)
    {
        this->salary = salary;
    }

    void toString()
    {
        cout << "userName = " << userName
             <<", Salary = " << salary << endl;
    }
};

//**********************迭代器接口***************************
//迭代器接口，定义访问和遍历元素的操作（双向遍历）
class Iterator
{
public:
    //移动到聚合对象的第一个位置
    virtual void first() = 0;
    //移动到最后一个位置
    virtual void last() = 0;
    //移动到聚合对象的下一个位置
    virtual void next() = 0;
    //移动到聚合对象的上一个位置
    virtual void previous() = 0;

    //判断是否到了尾部位置
    virtual bool isEof() = 0;
    //判断是否到了头部位置
    virtual bool isBof() = 0;

    //获取当前元素
    virtual Object* currentItem() = 0;
    virtual ~Iterator(){};
};

//************************************抽象聚合类**************************
//聚合对象的接口
class Aggregate
{
public:
    //创建相应迭代器对象的接口
    virtual Iterator* createIterator() = 0;
    //获取数量大小
    virtual int size() = 0;
    //获取指定位置的元素
    virtual Object* get(int index) = 0;
    //加入元素
    virtual void add(Object* o) = 0;
    virtual Aggregate* newInstance() {return NULL;}
    virtual ~Aggregate(){}
};

//***********************具体迭代器*****************************
//具体的迭代器对象
//用来实现访问数组的迭代接口，加入了迭代策略
//其主要思路就是在ArrayInterator中保存一份过滤后的Aggregate聚合对象数据。
class ArrayIterator : public Iterator
{
private:
    Aggregate* agg;

    //记录当前迭代到的位置索引
    int index;
public:
    ArrayIterator(Aggregate* agg)
    {
        index = 0;

        //在这里先对聚合对象的数据进行过滤，比如必须在3000以上
        this ->agg = agg->newInstance();//原型模式，根据agg的实际类型创建对象

        //下面用一般遍历方法，而不agg的迭代器，否则那样会造成死循环。
        for(int i = 0;i < agg->size(); i++)
        {
            Object* obj = agg->get(i);
            if (obj->getSalary()> 3000)
            {
                this->agg->add(obj);
            }
        }
    }

    void first()//移动到聚合对象的第1个位置
    {
        index = 0;
    }

    void last()//移动到聚合对象的最后一个位置
    {
        index = agg->size() -1;
    }

    //移动到聚合对象的下一个位置
    void next()
    {
        if(index < agg->size())
            ++index;
    }

    //移动到前一个位置
    void previous()
    {
        if(index>=0)
        {
            --index;
        }
    }

    //判断是否到了尾部位置
    bool isEof()
    {
        return (index >= agg->size());
    }

    //判断是否到了头部位置
    bool isBof()
    {
        return (index < 0);
    }

    //获取当前元素
    Object* currentItem()
    {
        //在这里对返回的数据进行过滤，比如不让查看具体的工资数据
        Object* obj = agg->get(index);
        obj->setSalary(0);
        return obj;
    }

    ~ArrayIterator()
    {
        delete agg;
    }
};

//用数组模拟具体的聚合对象
class SalaryManager : public Aggregate
{
private:
    //聚合对象
    vector<Object*> vecSalarys; //数组

    //提供创建具体迭代器的接口
    Iterator* mIter;
public:

    SalaryManager()
    {
        mIter = NULL;
    }

    Iterator* createIterator()
    {
        if (mIter == NULL)
        {
            mIter = new ArrayIterator(this);
        }
        return mIter;
    }

    //获取数量大小
    int size()
    {
        return vecSalarys.size();
    }

    //获取指定位置的元素
    Object* get(int index)
    {
        return vecSalarys[index];
    }

    //加入元素
    void add(Object* o)
    {
        vecSalarys.push_back(o);
    }

    Aggregate* newInstance()
    {
        Aggregate* ret = new SalaryManager();
        return ret;
    }
    ~SalaryManager()
    {
        delete mIter;
        vecSalarys.clear();
    }
};

int main()
{
    Aggregate* agg = new SalaryManager();

    //为了测试，输入些数据进去
    SalaryModel* sm = new SalaryModel();
    sm->setSalary(3800);
    sm->setUserName("张三");
    agg->add(sm);

    sm = new SalaryModel();
    sm->setSalary(5800);
    sm->setUserName("李四");
    agg->add(sm);

    sm = new SalaryModel();
    sm->setSalary(2200);
    sm->setUserName("王五");
    agg->add(sm);

    sm = new SalaryModel();
    sm->setSalary(3500);
    sm->setUserName("赵六");
    agg->add(sm);

    Iterator* it = agg->createIterator();

    //正向遍历
    it->first();
    while(!it->isEof())
    {
        it->currentItem()->toString();
        it->next();
    }

    //返向遍历、
    it->last();
    while(!it->isBof())
    {
        it->currentItem()->toString();
        it->previous();
    }

    return 0;
}
复制代码

（3）翻页迭代器

　　①在数据库访问中，如果每页显示10条记录，通常用户很少翻到10页以后，那么在第一次访问时，可以从从数据库中获取前10页的数据，即100条记录放在内存里。

　　②当用户在前10页进行翻页操作时，就可以不再访问数据库而是直接从内存中获取数据，速度就快了。

　　③当想获取第11页的数据时，才会再次访问数据库。而翻页迭代的意思是一次迭代要求取出一页的数据，而不是一条数据。所以其实现主要把原来一次迭代一条数据的接口，都修改成一次迭代一页的数据就可以了。

 【编程实验】带随机翻页功能的工资查看系统

复制代码 
//行为模式——迭代器模式
//场景：工资表数据遍历(带随机翻页功能)
//说明：翻页即每页读取若干条记录，
//      随机指可以指定页数和每页的记录数的访问方式，
//      而不是按顺序访问页面.

#include <iostream>
#include <string>
#include <vector>

using namespace std;
//***************************辅助类*************************
//前向声明
class Iterator;
class SalaryModel;
typedef SalaryModel Object;

//工资描述模型对象
class SalaryModel
{
private:
    string userName; //职工姓名
    double salary;      //工资数额
public:
    string& getUserName(){return userName;}
    void setUserName(string name)
    {
        this->userName = name;
    }

    double getSalary(){return salary;}
    void setSalary(double salary)
    {
        this->salary = salary;
    }

    void toString()
    {
        cout << "userName = " << userName
             <<", Salary = " << salary << endl;
    }
};

//**********************迭代器接口***************************
//迭代器接口，定义访问和遍历元素的操作（双向遍历）
class Iterator
{
public:

    //判断是否还有下一个元素，无所谓是否够一页数据
    //因为最后哪怕只有一条数据，也是要算一页。
    virtual bool hasNext() = 0;
    //判断是否还有上一个元素，无所谓是否够一页数据
    //因为最后哪怕只有一条数据，也是要算一页。
    virtual bool hasPrevious() = 0;

    //获取指定页号和每页显示的数量
    virtual  void getPage(int pageNum, int pageCount) = 0;

    virtual ~Iterator(){};
};

//************************************抽象聚合类**************************
//聚合对象的接口
class Aggregate
{
public:
    //创建相应迭代器对象的接口
    virtual Iterator* createIterator() = 0;
    //获取数量大小
    virtual int size() = 0;
    //获取指定位置的元素
    virtual Object* get(int index) = 0;
    //加入元素
    virtual void add(Object* o) = 0;
    virtual Aggregate* newInstance() {return NULL;}
    virtual ~Aggregate(){}
};

//***********************具体迭代器*****************************
//具体的迭代器对象
//用来实现访问数组的迭代接口，加入了迭代策略
//其主要思路就是在ArrayInterator中保存一份过滤后的Aggregate聚合对象数据。
class ArrayIterator : public Iterator
{
private:
    Aggregate* agg;

    //记录当前迭代到的位置索引
    int index;
public:
    ArrayIterator(Aggregate* agg)
    {
        index = 0;
        this ->agg = agg;
    }

    //判断是否还有下一个元素，无所谓是否够一页数据
    //因为最后哪怕只有一条数据，也是要算一页。
    bool hasNext()
    {
        return (index <agg->size());
    }
    //判断是否还有上一个元素，无所谓是否够一页数据
    //因为最后哪怕只有一条数据，也是要算一页。
    bool hasPrevious()
    {
        return (index >0);
    }

    //获取指定页号和每页显示的数量
    void getPage(int pageNum, int pageCount)
    {
        //这里可读取到的数据通过数组或链表返回给客户
        //但为了简便，我们在这里

        //计算需要获取的数据的开始条数和结束条数
        int start = (pageNum - 1)* pageCount;
        int end = start + pageCount - 1;

        //控制start的边界，最小是0
        if(start < 0)
            start = 0;

        //控制end的边界
        if(end > agg->size()-1)
            end = agg->size() -1;

        //每次取值都是从头开始循环
        index = 0;

        while(hasNext() && index <= end)
        {
            if(index>=start)
            {
                agg->get(index)->toString();
            }
            index++;
        }
    }
};

//用数组模拟具体的聚合对象
class SalaryManager : public Aggregate
{
private:
    //聚合对象
    vector<Object*> vecSalarys; //数组

    //提供创建具体迭代器的接口
    Iterator* mIter;
public:

    SalaryManager()
    {
        mIter = NULL;
    }

    Iterator* createIterator()
    {
        if (mIter == NULL)
        {
            mIter = new ArrayIterator(this);
        }
        return mIter;
    }

    //获取数量大小
    int size()
    {
        return vecSalarys.size();
    }

    //获取指定位置的元素
    Object* get(int index)
    {
        return vecSalarys[index];
    }

    //加入元素
    void add(Object* o)
    {
        vecSalarys.push_back(o);
    }

    Aggregate* newInstance()
    {
        Aggregate* ret = new SalaryManager();
        return ret;
    }
    ~SalaryManager()
    {
        delete mIter;
        vecSalarys.clear();
    }
};

int main()
{
    Aggregate* agg = new SalaryManager();

    //为了测试，输入些数据进去
    SalaryModel* sm = new SalaryModel();
    sm->setSalary(3800);
    sm->setUserName("张三");
    agg->add(sm);

    sm = new SalaryModel();
    sm->setSalary(5800);
    sm->setUserName("李四");
    agg->add(sm);

    sm = new SalaryModel();
    sm->setSalary(2200);
    sm->setUserName("王五");
    agg->add(sm);

    sm = new SalaryModel();
    sm->setSalary(3500);
    sm->setUserName("赵六");
    agg->add(sm);

    sm = new SalaryModel();
    sm->setSalary(2900);
    sm->setUserName("钱七");
    agg->add(sm);

    //得到翻页迭代器
    Iterator* it = agg->createIterator();

    //获取第一页，每页显示2条
    cout <<"第1页数据：" <<endl;
    it->getPage(1, 2);

    //获取第2页，每页显示2条
    cout <<"第2页数据：" <<endl;
    it->getPage(2, 2);

    //再获取第1页，每页显示2条
    cout <<"第1页数据：" <<endl;
    it->getPage(1, 2);

    //再获取第3页，每页显示2条
    cout <<"第3页数据：" <<endl;
    it->getPage(3, 2);

    return 0;
}
复制代码

4. 迭代器的优缺点

（1）优点

　　①更好的封装性，可对一个聚合对象的访问，而无须暴露聚合对象的内部实现。

　　②可以不同的遍历方式来遍历一个聚合对象（如正向和反向遍历）

　　③将聚合对象的内容和具体的迭代算法分离开，这样就可以通过使用不同的迭代器实例、不同的遍历方式来遍历一个聚合对象。

　　④简化客户端调用：迭代器为遍历不同的聚合对象提供了一个统一的接口，使用客户端遍历聚合对象的内容变得更加简单。

　　⑤同一个聚合上可以有多个遍历。每个迭代器保持它自己的遍历状态（如索引位置），因此可以对同一个聚合对象同时进行多个遍历。只要为其设置设计不同的迭代器。

（2）缺点：

　　①由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐。

　　②迭代器模式在遍历的同时更改迭代器所在的集合结构会导致出现异常。所以使用foreach语句只能在对集合进行遍历，不能在遍历的同时更改集合中的元素。

5. 应用场景

（1）如果希望提供访问一个聚合对象的内容，但又不想暴露它的内部表示的时候可使用迭代器模式

（2）如果希望有多种遍历方式可以访问聚合对象。

（3）如果希望为遍历不同的聚合对象提供一个统一的接口，可以使用迭代器模式（多态迭代）。

6. 相关模式

（1）迭代器模式和组合模式

　　组合模式是一种递归的对象结构，在枚举某个组合对象的子对象时，通常会使用迭代器模式。

（2）迭代器模式和工厂方法模式

　　在聚合对象创建迭代器的时候，通常会采用工厂方法模式来实例化相应的迭代器对象。

http://www.cnblogs.com/5iedu/p/5596939.html

linolzhang
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java常用设计模式-迭代器模式
08-28
java常用设计模式-迭代器模式
工厂方法和抽象工厂的区别
03-13 4197
工厂方法： 抽象工厂方法： 图示： 区别： 联系：
设计模式——迭代器模式（附代码示例）
枫陵的博客
05-25 4613
一. 传统方式 以学校院系展示为例，实现在一个页面展示学校的院系组成，一个学校有多个学院，一个学院有多个系。传统方式实现类图如下： 传统方式将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。实际上我们的要求是在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，而每个院对于系的存储方式各不相同（如数组、集合等），因此这种...
设计模式第16讲——迭代器模式（Iterator）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-25 5309
迭代器模式是一种行为型设计模式。一、什么是迭代器模式 二、角色组成 三、 优缺点 四、应用场景 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
设计模式——迭代器模式
程序猿进阶
03-25 2001
在程序设计中，经常需要访问一个聚合对象中的各个元素，例如：我们使用 list 存储元素，通常的做法是将 list 的创建和遍历放在同一个类中。但这种方法不利于扩展，如果将存储方式更改为数组时，就需要更换迭代方式。违背了 “开闭原则”。“迭代器模式” 能较好的克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与遍历行为，对客户也隐藏了其内部细节，满足 “单一职责原则” 和 “开闭原则”，如 Java 中的 Collection、List、Set、Map 等都包含迭代器。 一、迭代模.
工厂方法模式和抽象工厂模式之间的区别
tekkenvs11的专栏
03-05 485
    工厂方法模式属于对象创建型模式，它定义一个用户创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。 具体来说，就是一个一个抽象产品类，派生出多个具体产品类；同时，一个抽象工厂类，派生出多个具体工厂类。而每个具体工厂类只能创建一个具体产品类的实例。 抽象工厂模式也属于对象创建型模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无须制定它们具体的类...
JAVA-设计模式-行为型模式-迭代器模式
08-10
JAVA-设计模式-行为型模式-迭代器模式
c++设计模式-行为型模式-迭代器模式
06-25
c++设计模式-行为型模式-迭代器模式；qt工程；c++简单源码；迭代器（Iterator）模式的定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
设计模式--迭代器模式java例子
02-12
设计模式--迭代器模式java例子
设计模式之迭代器和职责链模式
02-21
(3)、优缺点：A、降低耦合度：该模式使得一个对象无需知道是其它哪一个对象处理其请求。对象仅需知道该请求会被”正确”地处理。接收者和发送者都没有对方的明确的信息，且链中的对象不需知道链的结构。结果是，职
工厂方法和抽象工厂区别
ListenUp
07-03 239
本文介绍工厂方法和抽象工厂区别。 　　工厂方法创建一般只有一个方法，创建一种产品。 　　抽象工厂一般有多个方法，创建一系列产品。 　　目的不一样 　　工厂方法创建 "一种" 产品，他的着重点在于"怎么创建"，也就是说如果你开发，你的大量代码很可能围绕着这种产品的构造，初始化这些细节上面。也因为如此，类似的产品之间有很多可以复用的特征，所以会和模版方法相随。 　　...
【设计模式——学习笔记】23种设计模式——迭代器模式Iterator（原理讲解+应用场景介绍+案例介绍+Java代码实现）
记录一名在读研究生的学习笔记、感悟、开发产物
08-03 1512
讲解迭代器模式的思想，介绍其常见的应用场景，举例说明其实现方式
迭代模式
码路编
11-09 381
迭代模式（Iterator） 迭代模式是行为模式之一，他把对容器中包含的内部对象的访问委让给外部类，使用Iterator按顺序进行遍历访问的设计模式。 不使用迭代模式存在的问题： 由容器自己实现顺序遍历。直接在容器类里直接添加顺序遍历方法。（容器类承担了太多功能：一方面需要提供添加删除等本身应有的功能；一方面还需要提供遍历访问功能） 让调用者自己实现遍历。直接暴露数据细节给外部。（往往容器在遍...
迭代模式 Iterator Pattern
hello
02-20 843
一、什么是迭代模式     Iterator模式也叫迭代模式，是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。 二、不使用迭代模式的应用 在应用Iterator模式之前，首先应该明白Iterator模式用来解决什么问题。或者说，如果不使用Iterator模式，会存在什么问题。 1.由容器自己实现顺序遍历。直接在容器
设计模式---工厂方法和抽象工厂的定义和区别
gc_baoyu的专栏
02-03 702
1、工厂方法模式：定义一个创建对象的接口，但由子类决定实例化的对象是哪一个，工厂方法让类把实例化推迟到了子类。 2、抽象工厂模式：提供一个接口，用于创建或依赖对象的家族，而不需要明确指定具体类。 3、二者将对象的创建封装起来，以便得到更松耦合，更有弹性设计。 4、设计原则：依赖抽象，不要依赖具体类。      依赖倒置原则：就是要依赖于抽象，不要依赖于具体。简单的说就是要求对抽象进行编程，
设计模式之迭代器模式
qq_42583549的博客
09-18 433
迭代器模式提供一种方法顺序访问一个聚合对象(将多个对象聚合在一起形成的总体)中的各个元素，而又不暴露该对象的内部表示，其本质是抽离集合对象迭代行为到迭代器中，对外提供一致的访问接口；迭代器和循环不是等价的，循环是迭代器的基础，迭代器是按照指定的顺序进行多次重复的循环某一程序，但是会有明确的终止条件；遍历是指按照规定访问非线性结构中的每一项 - 可以访问某一个区间段内的元素，而迭代只能按顺序依次访问；
23种设计模式之迭代器模式（Iterator Pattern）
热门推荐
小威的博客
05-27 2万+
本篇文章将23种设计模式中的迭代器模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
设计模式学习笔记（三）工厂模式中的简单工厂、工厂方法和抽象工厂模式之间的区别
hello_1566的博客
04-14 1179
设计模式中的工厂模式（Factory Design pattern）是一个比较常用的创建型设计模式，其中可以细分为三种：简单工厂（Simple Factory）、工厂方法(Factory Method)和抽象工厂(Abstract Factory)。那么三者有什么区别呢？先说结论： 简单工厂：只有唯一工厂（简单工厂），一个产品接口/抽象类，根据简单工厂中的静态方法来创建具体产品对象。适用于产品较少，几乎不扩展的情景 工厂方法：有多个工厂（抽象工厂+多个具体工厂），一个产品接口/抽象类，根据继承抽象工厂中的
设计模式（迭代器模式）
最新发布
11-12
迭代器模式是一种行为设计模式，它提供了一种方法来访问一个容器对象中的各个元素，而不需要暴露该对象的内部细节。迭代器模式通过提供一个迭代器来实现这一点，该迭代器用于遍历容器中的元素。迭代器模式在Java ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值