迭代器 订阅
迭代器(iterator)有时又称游标(cursor)是程序设计的软件设计模式,可在容器(container,例如链表或阵列)上遍访的接口,设计人员无需关心容器的内容。 展开全文
迭代器(iterator)有时又称游标(cursor)是程序设计的软件设计模式,可在容器(container,例如链表或阵列)上遍访的接口,设计人员无需关心容器的内容。
信息
外文名
iterator
别    称
游标卡尺
提出者
张康健
中文名
迭代器
适用领域范围
IT行业
迭代器解释
迭代器(iterator)是一种对象,它能够用来遍历标准模板库容器中的部分或全部元素,每个迭代器对象代表容器中的确定的地址。迭代器修改了常规指针的接口,所谓迭代器是一种概念上的抽象:那些行为上像迭代器的东西都可以叫做迭代器。然而迭代器有很多不同的能力,它可以把抽象容器和通用算法有机的统一起来。迭代器提供一些基本操作符:*、++、==、!=、=。这些操作和C/C++“操作array元素”时的指针接口一致。不同之处在于,迭代器是个所谓的复杂的指针,具有遍历复杂数据结构的能力。其下层运行机制取决于其所遍历的数据结构。因此,每一种容器型都必须提供自己的迭代器。事实上每一种容器都将其迭代器以嵌套的方式定义于内部。因此各种迭代器的接口相同,型号却不同。这直接导出了泛型程序设计的概念:所有操作行为都使用相同接口,虽然它们的型别不同。迭代器使开发人员能够在类或结构中支持foreach迭代,而不必整个实现IEnumerable或者IEnumerator接口。只需提供一个迭代器,即可遍历类中的数据结构。当编译器检测到迭代器时,将自动生成IEnumerable接口或者IEnumerator接口的Current,MoveNext和Dispose方法。1.迭代器是可以返回相同类型值的有序序列的一段代码;2.迭代器可用作方法、运算符或get访问器的代码体;3.迭代器代码使用yieldreturn语句依次返回每个元素,yield break将终止迭代;4.可以在类中实现多个迭代器,每个迭代器都必须像任何类成员一样有惟一的名称,并且可以在foreach语句中被客户端,代码调用如下所示:foreach(int x in SimpleClass.Iterator2){};5.迭代器的返回类型必须为IEnumerable和IEnumerator中的任意一种;6.迭代器是产生值的有序序列的一个语句块,不同于有一个 或多个yield语句存在的常规语句块;7.迭代器不是一种成员,它只是实现函数成员的方式,理解这一点是很重要的,一个通过迭代器实现的成员,可以被其他可能或不可能通过迭代器实现的成员覆盖和重载;8.迭代器块在C#语法中不是独特的元素,它们在几个方面受到限制,并且主要作用在函数成员声明的语义上,它们在语法上只是语句块而已;9.yield关键字用于指定返回的值。到达yieldreturn语句时,会保存当前位置。下次调用迭代器时将从此位置重新开始执行。 迭代器对集合类特别有用,它提供一种简单的方法来迭代不常用的数据结构(如二进制树)。迭代器是一种检查容器内元素并遍历元素的可带泛型数据类型。
收起全文
精华内容
参与话题
问答
  • 迭代器

    千次阅读 2019-07-11 18:43:10
    迭代器概述 迭代器是一种抽象的设计概念,在设计模式中iterator模式被定义为:提供一种方法,可以按序访问某一聚合物(容器)所含元素,且不暴露该聚合物的内部表达方式。 在STL中,迭代器又起着将容器与算法联合...

    迭代器概述

    迭代器是一种抽象的设计概念,在设计模式中iterator模式被定义为:提供一种方法,可以按序访问某一聚合物(容器)所含元素,且不暴露该聚合物的内部表达方式。

    在STL中,迭代器又起着将容器与算法联合到一起的作用。

    #include <iostream>
    #include <vector>
    #include <list>
    #include <deque>
    #include <algorithm>
    
    using namespace std;
    
    int main()
    {
    	const int arr[7]{1, 2, 3, 4, 5, 6, 7};
    
    	vector<int> varr(arr, arr + 7);
    	list<int> larr(arr, arr + 7);
    	deque<int> darr(arr, arr + 7);
    
    	vector<int>::iterator it1 = find(varr.begin(), varr.end(), 3);
    	list<int>::iterator it2 = find(larr.begin(), larr.end(), 4);
    	deque<int>::iterator it2 = find(darr.begin(), darr.end(), 5);
    
    	return 0;
    }

    上例用法就是常用的迭代器使用方式。find算法在查找时,与具体的数据结构无关,只要给出待查找数据集合的范围,find就可在该范围中查找,找到返回该元素在区间中的位置,否则返回end。

    所示的迭代器都是依附于容器创建、使用的,除此之外其实也可以设计一种泛型的迭代器。

    迭代器实现原理

    迭代器是一种行为类似指针的对象,因此迭代器实现上首先需要对" * " 和 " -> "进行重载。

    我们以list为对象,设计一个迭代器:

    // list结构
    template <typename T>
    class List{
        void insert_front (T value);
        void insert_end (T value);
        void display (std::ostream &os = std::cout)const;
    
    private:
        ListItem<T>* _end;
        ListItem<T>* _front;
        long _size;
    };
    
    tempalte <typename T>
    class ListItem{
    public:
        T value() const {return _value; }
        LsitItem* next()const {return _next; }
    
    private:
        T _value;
        ListItem* _next;
    }
    

    list底层结构为带头结点的双向循环链表,迭代器在移动时,只能按照链表的结构前后依次移动,因此链表的迭代器需要对原生态的指针进行封装,因为当对迭代器++时,应该通过节点中的next指针域找到下一个节点。 

    // 迭代器
    template<class T, class Ref, class Ptr>
    struct __list_iterator
    {
    	typedef __list_iterator<T, T&, T*> iterator;
    	typedef __list_iterator<T, const T&, const T*> const_iterator;
    	typedef __list_iterator<T, Ref, Ptr> self;
    
    	typedef bidirectional_iterator_tag iterator_category;
    	typedef T value_type;
    	typedef Ptr pointer;
    	typedef Ref reference;
    	typedef ptrdiff_t difference_type;
    
    	typedef ListItem<T>* link_type;
    	typedef size_t size_type;
    	link_type node;
    	__list_iterator(link_type x)
    		: node(x)
    	{}
    	__list_iterator()
    	{}
    	__list_iterator(const iterator& x)
    		: node(x.node)
    	{}
    	bool operator==(const self& x) const
    	{
    		return node == x.node;
    	}
    	bool operator!=(const self& x) const
    	{
    		return node != x.node;
    	}
    	reference operator*() const
    	{
    		return (*node).data;
    	}
    	pointer operator->() const
    	{
    		return &(operator*());
    	}
    	self& operator++(){
    		node = (link_type)((*node).next);
    		return *this;
    	}
    
    	self operator++(int)
    	{
    		self tmp = *this;
    		++*this;
    		return tmp;
    	}
    	self& operator--()
    	{
    		node = (link_type)((*node).prev);
    		return *this;
    	}
    	self operator--(int)
    	{
    		self tmp = *this;
    		--*this;
    		return tmp;
    	}
    };

     迭代器与类的融合

    1. 定义迭代器类


               2. 在容器类中统一迭代器名字

    // 如list:
    template <class T, class Alloc = alloc>
    class list
    {
    
        typedef __list_iterator<T, T&, T*> iterator;
        // ...
    };

    3. 在容器类中添加获取迭代器范围的接口:

    template <class T, class Alloc = alloc>
    class list
    {
    
        iterator begin()
        {
            return (link_type)((*node).next);
        }
        iterator end()
        {
            return node;
        }
        // ...
    };

     

     

    迭代器萃取参考:https://blog.csdn.net/LLZK_/article/details/53714015

     

    展开全文
  • C++之迭代器(Iterator)篇

    万次阅读 多人点赞 2017-07-28 10:52:21
    迭代器(Iterator)的介绍 背景:指针可以用来遍历存储空间连续的数据结构,但是对于存储空间费连续的,就需要寻找一个行为类似指针的类,来对非数组的数据结构进行遍历。 定义:迭代器提供对一个容器中的对象的...
    1. 迭代器(Iterator)的介绍
      背景:指针可以用来遍历存储空间连续的数据结构,但是对于存储空间费连续的,就需要寻找一个行为类似指针的类,来对非数组的数据结构进行遍历。
      定义:迭代器是一种检查容器内元素并遍历元素的数据类型。
      迭代器提供对一个容器中的对象的访问方法,并且定义了容器中对象的范围
      迭代器(Iterator)是指针(pointer)的泛化,它允许程序员用相同的方式处理不同的数据结构(容器)。
      (1)迭代器类似于C语言里面的指针类型,它提供了对对象的间接访问。
      (2)指针是C语言中的知识点,迭代器是C++中的知识点。指针较灵活,迭代器功能较丰富。
      (3)迭代器提供一个对容器对象或者string对象的访问方法,并定义了容器范围

    2. 迭代器和指针的区别:
      容器和string有迭代器类型同时拥有返回迭代器的成员。如:容器有成员begin和end,其中begin成员复制返回指向第一个元素的迭代器,而end成员返回指向容器尾元素的下一个位置的迭代器,也就是说end指示的是一个不存在的元素,所以end返回的是尾后迭代器

    3. 容器迭代器的使用
      每种容器类型都定义了自己的迭代器类型,如vector:vector< int>:: iterator iter;//定义一个名为iter的变量,数据类型是由vector< int>定义的iterator 类型。简单说就是容器类定义了自己的iterator类型,用于访问容器内的元素。每个容器定义了一种名为iterator的类型,这种类型支持迭代器的各种行为
      常用迭代器类型如下:
      这里写图片描述
      如上图所示,迭代器类型主要支持两类,随机访问和双向访问。其中vector和deque支持随机访问,list,set,map等支持双向访问。
      1)随机访问:提供了对数组元素进行快速随机访问以及在序列尾部进行快速插入和删除操作。
      2)双向访问:插入和删除所花费的时间是固定的,与位置无关。

    4. 迭代器的操作
      1、所有迭代器:
      这里写图片描述
      2、双向迭代器:
      这里写图片描述
      3、输入迭代器:
      列表内容
      4、输出迭代器
      这里写图片描述
      5、随机迭代器
      这里写图片描述

    资料引用:
    http://blog.csdn.net/qq_23100787/article/details/51388163
    特别鸣谢~

    展开全文
  • 迭代器(Iterator)

    万次阅读 多人点赞 2017-04-30 16:45:13
    迭代器(Iterator)是一个对象,它的工作是遍历并选择序列中的对象,它提供了一种访问一个容器(container)对象中的各个元素,而又不必暴露该对象内部细节的方法。通过迭代器,开发人员不需要了解容器底层的结构,就...

    迭代器(Iterator)是一个对象,它的工作是遍历并选择序列中的对象,它提供了一种访问一个容器(container)对象中的各个元素,而又不必暴露该对象内部细节的方法。通过迭代器,开发人员不需要了解容器底层的结构,就可以实现对容器的遍历。由于创建迭代器的代价小,因此迭代器通常被称为轻量级的容器。


    迭代器的使用主要有以下三个方面的注意事项:

    1)使用容器的iterator()方法返回一个Iterator,然后通过Iterator的next()方法返回第一个元素。

    2)使用Iterator()的hasNext()方法判断容器中是否还有元素,如果有,可以使用next()方法获取下一个元素。

    3)可以通过remove()方法删除迭代器返回的元素。


    Iterator支持派生的兄弟成员。ListIterator只存在于List中,支持在迭代期间向List中添加或删除元素,并且可以在List中双向滚动。


    Iterator的使用方法如下例所示:

    package com.js;
    /**
     * Iterator使用Demo
     */
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.List;
    
    public class Test {
    	public void main(String[] args){
    		List<String> ll = new LinkedList<String>();
    		ll.add("first");
    		ll.add("second");
    		ll.add("third");
    		ll.add("fourth");
    		for(Iterator<String> iterator = ll.iterator();iterator.hasNext();){
    			String string = (String)iterator.next();
    			System.out.println(string);
    		}
    	}
    }

    运行结果为:

    first
    second
    third
    fourth


    使用iterator()方法时经常会遇到ConcurrentModificationException异常,这通常是由于在使用Iteraor遍历容器的同时又对容器做增加或删除操作所导致的,或者由于多线程操作导致,当一个线程使用迭代器遍历容器的同时,另外一个线程对这个容器进行增加或删除操作。下列主要介绍单线程抛出ConcurrentModificationException的情况:

    package com.js;
    /**
     * Iterator使用Demo
     */
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.List;
    
    public class Test {
    	public void main(String[] args){
    		List<String> ll = new LinkedList<String>();
    		ll.add("first");
    		ll.add("second");
    		ll.add("third");
    		ll.add("fourth");
    		for(Iterator<String> iterator = ll.iterator();iterator.hasNext();){
    			String string = (String)iterator.next();
    			System.out.println(string);
    			if(string.equals("second"))
    				ll.add("fifth");
    		}
    	}
    }
    


    运行结果为:

    first
    second
    Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.LinkedList$ListItr.checkForComodification(Unknown Source)
    at java.util.LinkedList$ListItr.next(Unknown Source)
    at com.js.Test.main(Test.java:17)

    抛出上述异常的主要原因是当条用容器的iterator()方法返回Iterator对象时,把容器中包含对象的个数赋值给了一个变量expectedModCount,在调用next()方法时会比较变量expectedModCount与容器中实际对象的个数modCount的值是否相等,若二者不相等,则会抛出ConcurrentModificationException异常,因此在使用Iterator遍历容器的过程中,如果对容器进行增加或删除操作,就会改变容器中对象的数量,从而导致抛出异常。解决办法如下:在遍历的过程中把需要删除的对象保存到一个集合中,等遍历结束后再调用removeAll()方法来删除,或者使用iterator.remove()方法。


    以上主要介绍了单线程的解决方案,那么多线程访问容器的过程中抛出ConcurrentModificationException异常了又该怎么解决呢?

    1)在JDK1.5版本引入了线程安全的容器,比如ConcurrentHashMap和CopyOnWriteArrayList等。可以使用这些线程安全的容器来代替非线程安全的容器。

    2)在使用迭代器遍历容器时对容器的操作放到synchronized代码块中,但是当引用程序并发程度比较高时,这会严重影响程序的性能。


    引申:Iterator和ListIterator有什么区别?

    Iterator只能正向遍历集合,适用于获取移除元素。ListIterator继承自Iterator,专门针对List,可以从两个方向来遍历List,同时支持元素的修改。

    展开全文
  • JAVA设计模式--迭代器模式

    万次阅读 2017-02-11 13:01:59
    一、什么是迭代器模式 二、迭代器模式的结构 三、翻页迭代 四、迭代器模式的适用性 五、迭代器模式的优点 六、总结 一、什么是迭代器模式 迭代器(Iterator)模式又叫作游标(Cursor)模式,是一种对象的行为模式...

    目录

    一、什么是迭代器模式

    二、迭代器模式的结构

    三、翻页迭代

    四、迭代器模式的适用性

    五、迭代器模式的优点

    六、总结


    一、什么是迭代器模式

    迭代器(Iterator)模式又叫作游标(Cursor)模式,是一种对象的行为模式。提供一种方法顺序访问一个聚合(指一组对象的组合结构,如:Java中的集合、数组等)对象中各个元素,而又不需暴露该对象的内部表示。

    迭代器模式的本质:控制访问聚合对象中的元素

    设计意图:无须暴露聚合对象的内部实现,就能够访问到聚合对象中的各个元素。  

    二、迭代器模式的结构

    迭代器模式涉及的角色及其职责如下:

    抽象迭代器(Iterator)角色:一般定义为接口,用来定义访问和遍历元素的接口。
               具体迭代器(ConcreteIterator)角色:实现对聚合对象的遍历,并跟踪遍历时的当前位置。
               抽象聚合(Aggregate)角色:定义创建相应迭代器对象的接口。
               具体聚合(ConcreteAggregate)角色:实现创建相应的迭代器对象。

    迭代器模式结构示意源代码如下:

    先来看看抽象迭代器接口的定义。示例代码如下: 

    /**
     * 迭代器接口,定义访问和遍历元素的操作
     */
    public interface Iterator {
    
    	/**
    	 * 移动到聚合对象中第一个元素
    	 */
    	public void first();
    
    	/**
    	 * 移动到聚合对象中下一个元素
    	 */
    	public void next();
    
    	/**
    	 * 判断是否已经移动到聚合对象的最后一个元素
    	 */
    	public boolean isDone();
    
    	/**
    	 * 获取迭代的当前元素
    	 */
    	public Object currentItem();
    
    }
    

    接下来看看具体迭代器是如何实现的。示例代码如下:

    /**
     * 具体的迭代器实现类,不同的聚合对象所对应的迭代器实现是不一样的 以下示意的是数组聚合对象的迭代器
     */
    public class ConcreteIterator implements Iterator {
    
    	/**
    	 * 持有被迭代的具体的聚合对象
    	 */
    	private ConcreteAggregate aggregate;
    
    	/**
    	 * 内部索引,记录当前迭代到的位置
    	 */
    	private int index = -1;
    
    	/**
    	 * 构造方法,传入被迭代的具体的聚合对象
    	 * 
    	 * @param aggregate 被迭代的具体的聚合对象
    	 */
    	public ConcreteIterator(ConcreteAggregate aggregate) {
    		this.aggregate = aggregate;
    	}
    
    	/**
    	 * 移动到聚合对象中第一个元素
    	 */
    	@Override
    	public void first() {
    		index = 0;
    
    	}
    
    	/**
    	 * 移动到聚合对象中下一个元素
    	 */
    	@Override
    	public void next() {
    		if (index < this.aggregate.size()) {
    			index += 1;
    		}
    
    	}
    
    	/**
    	 * 判断是否已经移动到聚合对象的最后一个元素
    	 */
    	@Override
    	public boolean isDone() {
    		if (index == this.aggregate.size()) {
    			return true;
    		}
    		return false;
    	}
    
    	/**
    	 * 获取迭代的当前元素
    	 */
    	@Override
    	public Object currentItem() {
    		return this.aggregate.get(index);
    	}
    
    }
    

    再来看看抽象聚合类的定义。示例代码如下:

    /**
     * 聚合对象的接口,定义创建相应的迭代器对象的接口
     */
    public abstract class Aggregate {
    	/**
    	 * 工厂方法,创建相应的迭代器对象的接口
    	 */
    	public abstract Iterator createIterator();
    }

    下面该来看看具体聚合类是如何实现的了,这里以数组聚合对象的迭代器实现为例。示例代码如下: 

    /**
     * 具体的聚合对象,实现创建相应迭代器对象的功能
     *
     */
    public class ConcreteAggregate extends Aggregate {
    
    	/**
    	 * 示意,表示聚合对象具体的内容
    	 */
    	private String[] ss = null;
    
    	/**
    	 * 构造方法,传入聚合对象具体的内容
    	 * 
    	 * @param ss 聚合对象具体的内容
    	 */
    	public ConcreteAggregate(String[] ss) {
    		super();
    		this.ss = ss;
    	}
    
    	/**
    	 * 工厂方法,创建相应的迭代器对象的接口
    	 */
    	@Override
    	public Iterator createIterator() {
    		// 实现创建迭代器的工厂方法
    		return new ConcreteIterator(this);
    	}
    
    	/**
    	 * 根据索引位置,获取所对应的元素
    	 */
    	public Object get(int index) {
    		Object retObj = null;
    		if (index < ss.length) {
    			retObj = ss[index];
    		}
    		return retObj;
    	}
    
    	/**
    	 * 获取聚合对象的容量大小
    	 */
    	public int size() {
    		return this.ss.length;
    	}
    
    }
    

    在客户端中测试一下,示例代码如下。  

    public class Client {
    
    	public void someOperation() {
    		// 创建一个数组
    		String[] names = { "张三", "李四", "王五" };
    		// 创建聚合对象
    		ConcreteAggregate aggregate = new ConcreteAggregate(names);
    		// 获取聚合对象的迭代器
    		Iterator iterator = aggregate.createIterator();
    		// 移动到聚合对象中第一个元素
    		iterator.first();
    		int index = 1;
    		// 循环输出聚合对象中的值
    		while (!iterator.isDone()) {
    			Object obj = iterator.currentItem();
    			System.out.println("聚合对象中第" + (index++) + "个元素是:" + obj);
    			iterator.next();
    		}
    	}
    
    	public static void main(String[] args) {
    		Client client = new Client();
    		client.someOperation();
    
    	}
    
    }

    运行程序打印结果如下:  

    聚合对象中第1个元素是:张三
    聚合对象中第2个元素是:李四
    聚合对象中第3个元素是:王五

    从以上示例可以看出,迭代器模式为客户端提供了一个统一访问聚合对象的接口,通过这个接口就可以顺序地访问聚合对象的元素。对于客户端而言,只是面向这个接口在访问,根本不知道聚合对象内部的实现细节(聚合对象可以是集合,也可以是数组,客户端无从得知)。

    使用迭代器模式,还可以实现很多更加丰富的功能。比如:
               • 以不同的方式遍历聚合对象,比如向前、向后等。
               • 对同一个聚合同时进行多个遍历。
               • 以不同的遍历策略来遍历聚合,比如是否需要过滤等。
               • 多态迭代,含义是:为不同的聚合结构提供统一的迭代接口,也就是说通过一个迭代接口可以访问不同的聚合结构。(多态迭代可能会带来类型安全的问题,可以考虑使用泛型)  

    三、翻页迭代

    在实际开发中,经常会碰到需要一次迭代多条数据的情况,比如常用的翻页功能。翻页功能有如下几种实现方式。
              (1)纯数据库实现
               依靠SQL提供的功能实现翻页,用户每次请求翻页的数据,就会到数据库中获取相应的数据。
              (2)纯内存实现
               就是一次性从数据库中把需要的所有数据都取出来放到内存中,然后用户请求翻页时,从内存中获取相应的数据。

    两种方案各有优缺点:
               第一种方案明显是时间换空间的策略,每次获取翻页的数据都要访问数据库,运行速度相对比较慢,而且很耗数据库资源,但是节省了内存空间。
               第二种方案是典型的空间换时间,每次是直接从内存中获取翻页的数据,运行速度快,但是很耗内存。
             

    (3)纯数据库实现+纯内存实现
               思路是这样的:如果每页显示10条记录,根据判断,用户很少翻到10页以后,那好,第一次访问的时候,就一次性从数据库中获取前10页的数据,也就是100条记录,把这100条记录放在内存里面。
               这样一来,当用户在前10页内进行翻页操作的时候,就不用再访问数据库了,而是直接从内存中获取数据,速度就快了。当用户想要获取第11页的数据时,才会再次访问数据库。  

    四、迭代器模式的适用性

    在以下条件下可以考虑使用迭代器模式:
               • 如果你希望提供访问一个聚合对象的内容,但是又不想暴露它的内部表示的时候,可以使用迭代器模式来提供迭代器接口,从而让客户端只是通过迭代器的接口来访问聚合对象,而无须关心聚合对象的内部实现。
               • 如果你希望有多种遍历方式可以访问聚合对象,可以使用迭代器模式。
               • 如果你希望为遍历不同的聚合对象提供一个统一的接口,可以使用迭代器模式。  

    五、迭代器模式的优点

    更好的封装性
               • 迭代器模式可以让你访问一个聚合对象的内容,而无须暴露该聚合对象的内部细节,从而提高聚合对象的封装性。
               可以以不同的遍历方式来遍历一个聚合
               • 使用迭代器模式,使得聚合对象的内容和具体的迭代算法分离开。这样就可以通过使用不同的迭代器的实例、不同的遍历方式来遍历一个聚合对象了。
               实现功能分离、简化聚合的接口
               • 有了迭代器的接口,则聚合对象只需要实现自身的基本功能,把迭代的功能委让给外部的迭代器去实现,实现了功能分离,符合“单一职责”原则。
               简化客户端调用
               • 迭代器为遍历不同的聚合对象提供了一个统一的接口,一方面方便调用;另一方面使得客户端不必关注迭代器的实现细节。
               同一个聚合上可以有多个遍历
               • 每个迭代器保持它自己的遍历状态,比如前面示例中的迭代索引位置,因此可以对同一个聚合对象同时进行多个遍历。  

    六、总结

    聚合对象的类型很多,如果对聚合对象的迭代访问跟聚合对象本身融合在一起的话,会严重影响到聚合对象的可扩展性和可维护性。
               迭代器模式通过把对聚合对象的遍历和访问从聚合对象中分离出来,放入到单独的迭代器中,使得聚合对象变得简单;而且迭代器和聚合对象可以独立地变化和发展,大大加强了系统的灵活性。  

    展开全文
  • 迭代器的理解

    千次阅读 2018-07-29 11:53:40
    一、什么是迭代器 迭代,顾名思义就是重复做一些事很多次(就现在循环中做的那样)。迭代器是实现了__next__()方法的对象(这个方法在调用时不需要任何参数),它是访问可迭代序列的一种方式,通常其从序列的第一个...
  • Java中迭代器的学习

    2020-05-23 11:37:37
    迭代器 1.迭代器内部的设计 /* 并不是所有的集合都有索引,以前使用for+get方法(索引) 遍历集合的方式,就行不通了 jdk提供了一种遍历集合的通用方式(遍历集合的工具): 迭代器 迭代器接口: java.util.Iterator<...
  • C++迭代器操作

    千次阅读 2019-03-09 10:54:35
    一、advance 头文件iterator template &lt;class InputIterator, class Distance&gt; void advance ...如果它是随机访问迭代器,则该函数仅使用一次operator +或operator-。 否则,该函数重复...
  • 什么是迭代器(Iterator)

    万次阅读 2017-10-13 11:01:56
    转自:牛客网 ...迭代器可以在迭代过程中删除底层集合的元素,但是不可以直接调用集合的remove(Object obj)删除,可以通过迭代器的remove()方法删除 二、使用Iterator的简单例子 public class
  • 迭代器是什么

    万次阅读 多人点赞 2010-05-07 16:06:00
    在学习c++ STL的时候,整天碰到迭代器,也整天用,但是,到底它是个什么东西,很多人没有一个认识。这里我通过几个小的DEMO,来看看迭代器。首先我实现了一个十分简陋的vector类:template class vector {private: T...
  • C++迭代器实现原理(附带了Java)

    千次阅读 2018-05-11 17:15:29
    只要用过C++的容器,相信大家对迭代器都不会陌生。它提供一种统一的接口形式来遍历相应的容器(例如数组,链表,map等)。 例子1:迭代器的遍历 利用迭代器遍历数组vector vector&amp;lt;int&amp;gt; ...
  • 迭代器模式

    2018-04-22 22:02:20
    迭代器模式(Iterator):提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露该对象的内部表示多个对象聚在一起形成的总体称之为聚集(Aggregate),聚集对象是能够包容一组对象的容器对象。一个聚集对象,不管对象...
  • Java 设计模式之迭代器模式

    千次阅读 2018-01-29 10:41:30
    (一)了解迭代器模式 1.1什么是迭代器模式 迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露其内部的表示。 迭代器模式把游走的任务放在迭代器上,而不是聚合上。这样简化了聚合的接口和实现...
  • Java设计模式——迭代器模式

    千次阅读 2016-03-04 12:39:41
    概述 网上大部分人说迭代模式的时候,总是以某一种可遍历... 本文介绍的这种迭代模式,倒是更像是适配器-迭代器模式。希望于你有益~ 版权说明 著作权归作者所有。 商业转载请联系作者获得授权,非商业转载请注...
  • 设计模式 | 迭代器模式及典型应用

    千次阅读 2018-10-11 23:09:59
    介绍迭代器模式 源码分析迭代器模式的典型应用 Java集合中的迭代器模式 Mybatis中的迭代器模式 更多内容请访问我的个人博客:http://laijianfeng.org 迭代器模式 迭代器模式(Iterator Pattern):提供一种方法...
  • 请问STL迭代器和设计模式中的迭代器之间的异同点,stl迭代器是否使用了迭代器模式
  •  如果要问Java中使用最多的一种模式,答案不是单例模式,也不是工厂模式,更不是策略模式,而是迭代器模式,先来看一段代码吧: [java] view plaincopy public static void 
  • 设计模式-迭代器模式 C++实现

    千次阅读 2017-09-17 15:19:56
    一个聚合对象,如一个列表(List)或者一个集合(Set),应该提供一种...怎样遍历一个聚合对象,又不需要了解聚合对象的内部结构,还能够提供多种不同的遍历方式,这就是迭代器模式所要解决的问题。1.模式定义迭代器模式(It
  • 在软件开发领域中,人们经常会用到这一个概念——“设计模式”(design pattern),它是一种针对软件设计的共性问题而提出的解决方案。在一本圣经级的书籍《设计模式:可复用...迭代器模式就是其中的一种,在各种...
  • (给Python开发者加星标,提升Python技能)作者:豌豆花下猫 (本文来自作者投稿)在软件开发领域中,人们经常会用到这一个概念——“设计模式”(design pat...
  • 你好我是辰兮,很高兴你能来阅读,本篇给你介绍Java设计模式之迭代器模式,简单的讲解Iterator具体如何使用,分享给初学者,大家一起进步! 文章目录一、迭代器介绍二、ArrayList案例三、HashMap案例四、拓展相关 ...
  • ArrayList与迭代器模式

    千次阅读 2017-08-09 08:26:32
    本文主要讲解迭代器模式在ArrayList源码中的使用。 迭代器模式(Iterator Pattern):提供一种方法来访问聚合对象中的各个元素,而不用暴露这个对象的内部表示。在Java中,ArrayList的迭代器有两种:Iterator和...
  • JavaScript设计模式之迭代器模式

    千次阅读 2019-01-21 22:10:00
    迭代器模式是指提供一种方法顺序访问一个聚合对象中的各个元素,而又不需要暴露该对象的内部表示。迭代器模式可以把迭代的过程从业务逻辑中分离出来,在使用迭代器模式之后,即使不关心对象的内部构造,也可以按顺序...
  • 迭代器模式的简介 迭代器模式的抽象代码 迭代器模式的具体代码 迭代器模式的内部迭代器 jdk自带的迭代器 迭代器模式的优点 迭代器模式的缺点 迭代器模式的适用场景 迭代器模式的简介 在软件开发中,我们...
  • 迭代器模式分为内部迭代器和外部迭代器,内部迭代器就是在函数内部定义好迭代的规则,它完全接手整个迭代的过程,外部只需一次初始调用。 内部迭代器 以下自行实现的类似jquery中$.each()的each()函数就是内部迭代器...
  • 迭代器模式简析

    千次阅读 2018-06-08 15:02:15
    目的:提供一种方法顺序访问聚合对象中的元素,而不暴露其内部表示解决问题:以不同方式遍历聚合对象原理:聚合类中保留聚合对象存储内部数据的职责,而降遍历内部数据的职责交给迭代器来完成,以实现“单一职责”的...
  • C++设计模式之迭代器模式

    千次阅读 2015-04-16 16:29:28
    前言 又到年底了,时间真的过的好快啊。最近也非常感伤,总是怀念大学的日子,做梦的时候也常常梦到。梦到大学在电脑前傻傻的敲着键盘,写着代码,对付着数据结构与算法的作业;建立一个链表,遍历链表,打印链表。...
  • PHP设计模式——迭代器模式

    千次阅读 2015-06-08 22:08:41
     迭代器模式迭代器模式是遍历集合的成熟模式,迭代器模式的关键是将遍历集合的任务交给一个叫做迭代器的对象,它的工作时遍历并选择序列中的对象,而客户端程序员不必知道或关心该集合序列底层的结构。...
  • 迭代器模式例子

    千次阅读 2016-12-08 22:03:55
    一、概述 ... 2) 具体迭代器角色(Concrete Iterator):具体迭代器角色要实现迭代器接口,并要记录遍历中的当前位置。  3) 容器角色(Container):容器角色负责提供创建具体迭代器角色的接口。
  • 迭代器模式(Iterator) 在现实生活以及程序设计中,经常要访问一个聚合对象中的各个元素,如“数据结构”中的链表遍历,通常的做法是将链表的创建和遍历都放在同一个类中,但这种方式不利于程序的扩展,如果要更换...
  • 23种设计模式(13):迭代器模式

    万次阅读 多人点赞 2012-05-28 21:54:03
     如果要问java中使用最多的一种模式,答案不是单例模式,也不是工厂模式,更不是策略模式,而是迭代器模式,先来看一段代码吧: public static void print(Collection coll){ Iterator it = coll.iterator()

空空如也

1 2 3 4 5 ... 20
收藏数 558,025
精华内容 223,210
关键字:

迭代器