tera

三个in-ter-act，这叫多音节词，英语的音节是按照元音来划分的。

它做名词的时候，与intermezzi相似，为“幕间剧“ 做动词的时候，与interplay,interwork相似，为”相互作用，相互影响“

interaction

我认为两个词是没有区别的，事实上我字典里interplay的解释是“To act or react on each other; interact ” 也就是说两个词本身就是同义词。如果硬要说用法上有什么区别，我认为那就是interplay本身作名词的时候意思仍旧保持不变，而interact的名词是interaction。例句：Interplay(本身就有名词用法，如下面例句)u2022We can examine the interplay between the different questions, to find out how people"s judgements are formed. u2022These results are determined by the complex interplay of several feedback processes involving agents, resources and memes.Interact （动词，搭配with）u2022Interact with an audience is being evaluatedInteractiveu2022But we would run an event for you on how to create interactive learning activities in Word. u2022Once you become interactive you will know you are never alone.

前者的发音更正确。

网页链接

counter是反对，相反的意思，act是行为动作，那么counteract是指反对的行为，抵制的意思；off是偏离的意思，set是设定的意思，offset是偏离设定。

The SleeperAt midnight, in the month of June在六月的午夜I stand beneath the mystic moon我站在神秘的月亮下An opiate vapor, dewy, dim带着露水微弱、迷幻的雾气Exhales from out her golden rim从它黄金的轮廓中散发And, softly dripping, drop by drop轻柔的水滴，慢慢滴落Upon the quiet mountain top爬上寂静山峰的顶端Steals drowsily and musically懒洋洋唱着歌偷偷Into the universal valley进入了宇宙的山谷The rosemary nods upon the grave迷迭香向坟墓摇摆The lily lolls upon the wave百合花轻轻挥舞Wrapping the fog about its breast浓雾包裹住它的胸膛The ruin molders into rest毁灭腐烂的部分坠入长眠之中Looking like Lethe, see! the lake就像被遗忘，看啊！湖水A conscious slumber seems to take意识的睡眠被And would not, for the world, awake从这个世界上带走All Beauty sleeps ,and lo! where lies所有美丽的沉睡者都将醒来Irene, with her Destinies和平女神和她的命运O, lady bright! can it be right美丽的女神！让一切完美This window open to the night打开夜晚的窗The wanton airs, from the tree-top淫荡的空气，来自树梢顶端Laughingly through the lattice drop笑声穿过格子落下The bodiless airs, a wizard rout无躯体的空气，巫师的盛宴Flit through thy chamber in and outAnd wave the curtain canopy掠过你的房间，进进出出吹皱起苍穹的帷幕So fitfully- so fearfully断断续续Above the closed and fringed lid在流苏遮蔽的穹顶之上′Neath which thy slumb′ring soul lies hid灵魂的谎言隐藏在催眠的雨后That, o′er the floor and down the wall覆盖了大地，冲垮了围墙Like ghosts the shadows rise and fall就像鬼魂的阴影在起起落落Oh, lady dear, hast thou no fear?爱人，你可曾感到恐惧？Why and what art thou dreaming here?这美景为什么只有在梦中浮现？Sure thou art come O′er far-off seas越过遥远深沉海洋A wonder to these garden trees惊讶于花园中树林Strange is thy pallor! strange thy dress惊讶于你的苍白和衣着Strange, above all, thy length of tress惊讶于你的长发，惊讶于所有这些And this all solemn silentness所有这些寂静的庄严The lady sleeps! Oh, may her sleep沉睡的女士Which is enduring, so be deep这忍耐深沉强烈Heaven have her in its sacred keep天堂是她神圣的祭礼This chamber changed for one more holy这房间为更多的神圣改变This bed for one more melancholy这睡眠饱含哀思I pray to God that she may lie我祈祷神只是她的谎言For ever with unopened eye永远不能打开的眼睛While the pale sheeted ghosts go by当灰白色的鬼魂经过My love, she sleeps! Oh, may her sleep我沉睡的爱人As it is lasting, so be deep那是永远，无尽的沉睡Soft may the worms about her creep当蠕虫在她周围爬动Far in the forest, dim and old遥远的树林，阴暗古老For her may some tall vault unfold为她打开墓穴Some vault that oft has flung its black地下的灵堂投入黑色的怀抱And winged panels fluttering back振翅回飞Triumphant, o"er the crested palls胜利，跨过带有顶饰的棺木Of her grand family funerals豪华的家庭葬礼Some sepulchre, remote, alone一些坟墓，偏远孤独Against whose portal she hath thrown她被投进死亡的大门In childhood, many an idle stone在童年，无用的宝石Some tomb from out whose sounding door来自一些坟墓的大门She ne′er shall force an echo more她无力回应Thrilling to think, poor child of sin可怕的思想，罪恶之子It was the dead who groaned within死亡在它内部呻吟。

next会前移一位，集合里只有一项，你调用两次next

我一般用for~~~

即使是线程安全的集合，使用iterator()进行迭代都是不安全的，必须手动地进行同步

iterator已经是一个类型了，换一个名称吧，比如：typedef list<Property<N,V> >::iterator PropertyIterator; typedef list<Property<N,V> >::const_iterator PropertyConstIterator;

iterator是迭代器的意思。这句话是定义一个string::iterator类型的变量itr，初始化为mlp.end()-1。mlp是string类型对象，mlp.end()返回一个迭代器指向string对象末端元素的下一个位置，-1后就是指向string对象的最后一个元素。比如string mlp("asdf");string::iterator itr=mlp.end()-1;此时，itr指向mlp的最后一个元素f

STL标准中的说法是未定义，或者说是某某操作会让迭代器失效，并且不要使用未定义或者失效的迭代器。但各家编译器的具体实现各不相同，曾经做过vector和map的迭代器在红帽Linux、HPUX和IBMAIX上越界后的实验，最严重的反应是程序直接跑飞了。为了程序更好的兼容性，听标准的话吧。

迭代器（Iterator）模式，又叫做游标（Cursor）模式。GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。 从定义可见，迭代器模式是为容器而生。很明显，对容器对象的访问必然涉及到遍历算

存放有bcd的集合

没错，是这样的

将j中的值遍历出来，放入list中，在iterator i = list.iterator();这样就可以了吧

你的集合类用的什么？还不如用范型，然后用foreach循环，这样来的简单些。

如果只是用iterator，那stream就是多此一举。stream是为了方便map，filter，等

能，Iterator(迭代器)不是一个集合,它是一种用于访问集合的方法,可用于迭代ArrayList和HashSet等集合。

const_iterator是声明iterator指向的对象是常量，即iterator指向常对象，其本身可以变const iterator是声明iterator是常量，其指向的对象可以改变，但其本身不能变eg.vector<int>::const_iterator iter1 = vec.cbegin();*iter = 3; //Error++iter; //Okconst vector<int>::iterator iter2 = vec.begin();*iter = 4; //Ok++iter; //Error

容器就是数据结构的泛指，迭代器就是指针的泛指，可以指向元素。容器相当于一个储藏柜，里面装的许多不同的物品就像是储存的元素，比如面包、啤酒、苹果、现金。要取得各个物体就得用与各个物体向匹配的工具，如取出面包要用盘子、取出啤酒要用杯子、取出苹果要用篮子、取出现金要用钱包。迭代器的作用就相当于取出物品的工具的抽象，通过迭代器泛指现实生活中从贮藏室中取出物体的工具。C++迭代器是一种检查容器内元素并遍历元素的数据类型。1 Iterator definitionsIn C++, an iterator is any object that, pointing to some element in a range of elements (such as an array or a container), has the ability to iterate through the elements of that range using a set of operators (at least, the increment (++) and dereference (*) operators). The most obvious form of iterator is a pointer: A pointer can point to elements in an array, and can iterate through them using the increment operator (++). But other forms of iterators exist. For example, each container type (such as a vector) has a specific iterator type designed to iterate through its elements in an efficient way.C++迭代器Interator就是一个指向某种STL对象的指针。通过该指针可以简单方便地遍历所有元素。 C++中的iterator为STL中的重要概念。iterator的概念源自于对遍历一个线性容器工具的抽象，即如何你能访问这个容器的某个元素。对于最简单的数组，当然可以用数组的索引值，因为数组是连续存放在内存中的；但对于链表，就必须用指针。除此之外，还有还有很多种数据结构需要提供一个方便的工具来访问其中的元素，方法有ID，关键字等等。为了统一所有的容器的这种工具的使用，一般提供一整套容器的开发者就会用一种方式来表示各种容器的访问工具。例如C＋＋ STL就是使用iterator。MFC自己的容器使用position。C#和java也有自己的方法，但方法是不变的。 iterator的用法可以被统一，但不同的底层容器实现其iterator的原理是不一样的。例如iterator++你可以理解为移动到容器的下一个元素，如果底层如果是数组，把索引值加一就行；如果底层是链表，就得执行类似于m_pCurrent = m_pCurrent-> pNext;的操作。因此每种容器都有自己的iterator实现方法。 C++ STL iterator的常用方法有： iterator++ 移到下个元素 iterator-- 移到上个元素 *iterator 访问iterator所指元素的值 < > == != iterator之间的比较，例如判断哪个元素在前 iterator1 + iterator2 iterator之间的加法运算，类似于指针加法 2 容器的 iterator 类型每种容器类型都定义了自己的C++迭代器类型，如 vector：vector<int>::iterator iter;这符语句定义了一个名为 iter 的变量，它的数据类型是 vector<int> 定义的 iterator 类型。每个标准库容器类型都定义了一个名为 iterator 的成员，这里的 iterator 与迭代器实际类型的含义相同。begin 和 end 操作每种容器都定义了一对命名为 begin 和 end 的函数，用于返回迭代器。如果容器中有元素的话，由 begin 返回的迭代器指向第一个元素： vector<int>::iterator iter = ivec.begin();上述语句把 iter 初始化为由名为 vector 操作返回的值。假设 vector 不空，初始化后，iter 即指该元素为ivec[0]。由end 操作返回的C++迭代器指向 vector 的“末端元素的下一个”。“超出末端迭代器”（off-the-end iterator）。表明它指向了一个不存在的元素。如果 vector 为空，begin 返回的迭代器与 end 返回的迭代器相同。由 end 操作返回的迭代器并不指向 vector 中任何实际的元素，相反，它只是起一个哨兵（sentinel）的作用，表示我们已处理完 vector 中所有元素。a)使用迭代器读取vector中的每一个元素vector<int> ivec(10,1); for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter){*iter=2; //使用 * 访问迭代器所指向的元素}b)const_iterator只能读取容器中的元素，而不能修改for(vector<int>::const_iterator citer=ivec.begin();citer!=ivec.end();citer++){cout<<*citer; //*citer=3; error}3 vector 迭代器的自增和解引用运算C++迭代器类型定义了一些操作来获取迭代器所指向的元素，并允许程序员将迭代器从一个元素移动到另一个元素。迭代器类型可使用解引用操作符（dereference operator）（*）来访问迭代器所指向的元素：*iter = 0;解引用操作符返回迭代器当前所指向的元素。假设 iter 指向 vector 对象 ivec 的第一元素，那么 *iter 和ivec[0] 就是指向同一个元素。上面这个语句的效果就是把这个元素的值赋为 0。迭代器使用自增操作符向前移动迭代器指向容器中下一个元素。从逻辑上说，C++迭代器的自增操作和int 型对象的自增操作类似。对 int 对象来说，操作结果就是把 int 型值“加 1”，而对迭代器对象则是把容器中的迭代器“向前移动一个位置”。因此，如果 iter 指向第一个元素，则 ++iter 指向第二个元素。由于 end 操作返回的迭代器不指向任何元素，因此不能对它进行解引用或自增操作。

it.size（）

难道是Iterrator的类来源不是util么?感觉遍历没问题啊...要不要加个泛型试试...不过下面的book范围有没有问题啊...

for,while是一样的，形式上的不同foreach,Iterator也是一样的，形式上的不同性能肯定是用迭代器的好一些。迭代器能直接访问集合内部元素。而且有的集合没有索引，没法用for来遍历，只有用迭代器。

List本来就是有序的集合，你可以直接用for(int i=0;i<list.size();++){..}这种方式遍历集合元素。

Iterator 是集合的一个迭代器for循环里面的意思是Iterator iter=buses.iterator()//获取一个迭代器中当前位置的对象iter.hasNext()//迭代器中后面是否还有东西最后留空表示没有限制 因为你在for循环内部调用了iter.next()方法 指针会自动向后移动建议不要这么写最好for(int i=0;i<list,size();i++){ Car car=(Car)list.get(i);}还有 Arraylist可以使用泛型 则该list只能添加对应泛型的对象 如:ArrayList<Car> list=new ArrayList<Car>();Car car=new Car();list.add(car);迭代时可以使用这个for(Car car:list){ system.out.println(car);}

既然你用的是Set集合 那么就不存在重复问题了 呵呵 如果是你拿到数据放到set里面 那么就进行一个equels（）判断 if（）else，就解决了

next效率远比get高

set本身就是用来赋值的啊！

迭代，这样方便获取集合c中的值

ger.java类中有这么一个内部类 private static class IntegerCache { private IntegerCache(){} static final Integer cache[] = new Integer[-(-128) + 127 + 1]; static { for(int i = 0; i < cache.length; i++) cache[i] = new Integer(i - 128); } } public static Integer valueOf(int i) { final int offset = 128; if (i >= -128 && i <= 127) { // must cache return IntegerCache.cache[i + offset]; } return new Integer(i); }这段代码,因为你用的是5.0中的自动装箱特性.从理论上来说是Integer是一个类而int是基本数据类型.一个是对象而一个是数据类型两者是不能强制类型转换的,之所以你能用(Integer)x将int类型的变量x强制类型转换成Integer,创建出一个Integer类型的对象,是因为JAVA在5.0中当类Integer.class加载的时候就帮你自动在池中创建了-128到127之间的Integer对象.当你进行强制类型转换的时候并不是将创建出一个Integer对象出来而是去池中拿出一个-128到127之间的Integer对象来给你用。所以你知道为什么不能remove掉那个元素,因为池中没有所以虚拟机从池中拿不出来所以你强制类型转换以后就什么都没有了.如果你要程序能remove掉X元素你可以这样写:List c = new ArrayList(); int x = 128; c.add("hello"); c.add(new Integer(x)); System.out.println(c); for (Iterator ii = c.iterator(); ii.hasNext();) { if (ii.next().equals(new Integer(x))) { ii.remove(); } } System.out.println(c.toString);另外,虚机团上产品团购,超级便宜

generator是生成器，当然是用来生成某些东西。「generator」生成「Iterator对象」

you got it

看一下jdk文档。就知道了。

楼主是C++写的程序hoxolo123回答的是Java的，而且和splice函数一点关系没有

keyset()是获取所有的key值，iterator()是迭代遍历，keySet().iterator()返回一个hm.keySet ()的迭代。

for循环是语言中循环控制结构。而iterator则是用来遍历集合中的元素。本身是不能够循环遍历需要借助循环控制语句进行迭代元素。个人认为iterator封装了循环体遍历元素的细节，使得编程人员无需关心集合结构，以及访问元素的操作。例如:for(inti=0;i评论00加载更多

不是迭代器接口(Iterator)所定义的方法是（） A.hasNext（）B.next（）C.remove（）D.nextElement（）正确答案：nextElement（）

Map集合不能使用iterator遍历，但是可以用下面的方式遍历Map public static void main(String[] args) { Map map = new HashMap(){}; map.put(1, "A"); map.put("a", "B"); map.put("A", "C"); map.put(new Object(), "D"); Iterator iterator = map.keySet().iterator(); while (iterator.hasNext()) { System.out.println(map.get(iterator.next()).toString()); } }

while(bank.getCustomers().hasNext())每次，都重新得到Customers

也学习一下

list.get(0);list.get(list.size()-1);从来不建议用iterator来读List，除非是为了偷懒foreach，不然别用这个烂玩意。直接当数组用，多方便啊。

可以用iterator();

是问他的发音呢还是在程序中的使用方法？

这是计算机编程里面的吧，意思就是把al.iterator()这个命令赋值给 Iterator it，命令的意思应该是对其进行迭代，计算机方面我也不太懂。不属于翻译领域：）

接口 Iterator 专门的迭代输出接口，将元素一个个进行判断，用hasNext() 判断是否有值，用next()方法把元素取出。 hasNext() 如果仍有元素可以迭代，则返回 true。 next() 返回迭代的下一个元素。 经验的总结是只要碰到了集合输出的操作，就一定.

你可以输出调试信息，或者写日志看看为什么不一样

关于你的疑问，请参考我的学习笔记吧。hasNext、next方法：迭代器用于遍历集合元素。获取迭代器可以使用Collection定义的方法：Iterator iterator()迭代器Iterator 本身是一个接口，集合在重写Collection的iterator()方法时利用内部类提供了迭代器的实现。Iterator提供了统一的遍历集合元素的方式，其提供了用于遍历集合的两个方法：boolean hasNext()判断集合是否还有元素可以遍历。E next() 返回迭代的下一个元素。每一种集合的实现类都是各自的迭代器实现，不用关心具体迭代器的类型，只将他们当作迭代器用于遍历集合元素即可。应当遵循“问-取-删”模式，适用于while循环。Iterator<String>it = c1.iterator(); --- 问的过程，询问c1集合中是否还有元素while( it.hasNext() ){ String str = (String) it.next(); --- 取出来的是Object类型，所以需要转换类型} 注意：应建立在hasNext返回true的基础上执行next()方法迭代过程中，不能调用集合的相关方法来改变集合中的元素，不然会抛出异常。应使用迭代器自身提供的方法操作。迭代器的删除方法是在原集合中删除元素。在调用remove方法前必须通过迭代器的next()方法迭代过元素，那么删除的就是这个元素，并且不能连续接着调用remove。While( it.hasNext() ){String str = (String) it.next();if(“#”.equals ( str ) ){ //凡是相互比较，应当让字变量.equals(变量),可以避免遇到null空指针异常it.remove();}}

iterator 的子类ListIterator<E>可以从按任意方向遍历列表、向前往后遍历使用next() 返回列表中的下一个元素,从后往前使用previous() 返回列表中的前一个元素。

我晕，到金山词霸上去查下就行了，像计算机语言这个东西，有的都差不多，你知道怎么用就行了嘛

链表的一些方法使用和迭代器的使用（把链表内的元素迭代出），你可以看下~ import java.util.*;public class test11 {static LinkedList list = new LinkedList();String[] arrays = {"1","2","3","4","5"};static Iterator it ;public static void main(String[] args) {test11 t = new test11();t.useLinkedList(list);t.useIterator(list,it);}//链表的使用public void useLinkedList(LinkedList list){for(int i = 0;i < 5;i++)list.add(arrays[i]);//把数组的元素都添加到链表System.out.println("操作前的长度:"+list.size());//打印出链表的长度System.out.println("此列表的头（第一个元素）为:"+list.peek());/*peek() 找到但不移除此列表的头（第一个元素）。*/System.out.println("查找后的长度:"+list.size());System.out.println("移除的元素为:"+list.poll()); /*poll() 找到并移除此列表的头（第一个元素）。*/System.out.println("移除后的长度:"+list.size());System.out.println("返回第一个元素:"+list.getFirst());//getFirst() 返回此列表的第一个元素。System.out.println("返回最后一个元素:"+list.getLast());//getLast() 返回此列表的最后一个元素。if(list.contains("4"))//boolean contains(Object o) 如果此列表包含指定元素，则返回 true。 System.out.println("存在此元素");elseSystem.out.println("不存在此元素");}//迭代器的使用public void useIterator(LinkedList list,Iterator it){it = list.iterator();//将链表的元素迭代出并打印while(it.hasNext())System.out.print(it.next()+" ");}}

抽象类

<s:iterator value="list" id="user" status="L"><s:property value="#L.index+1"/>、<s:property value="#user.name"/><br></s:iterator>#L.index，即为list的索引其中L是个IteratorStatus对象List<User>User对象含有name和password属性。当然你也可以写成：<s:iterator value="list" id="user" status="L"><s:property value="${L.index+1}"/>、<s:property value="${user.name}"/><br></s:iterator>

JAVA集合主要分为三种类型：　Set(集) 　List(列表) 　　Map(映射)iterator 就是迭代器，是遍历集合的一种方式！ 具体请看：http://baike.baidu.com/view/1413849.htm?fr=aladdin　　

<string>在这里是泛型，你上面那句不写tostring（），得到的也是string类型的数据。

iterator顾名思义是迭代器的意思。他是一个可迭代的类型的迭代器。从使用的角度看，她是一个指向其元素的引用。比如对于int[]这样的，其就是一个指向数组元素的非空指针。对于std::vector这样的，就是指向一个std::vector::iterator定义的类型。所以，对于迭代器，可以使用operator->和operator*。

使用 Iterator 的子接口 ListIterator里面有个方法hasPreviousboolean hasPrevious()如果以反向遍历列表，列表迭代器有多个元素，则返回 true。（换句话说，如果 previous 返回一个元素而不是抛出异常，则返回 true）。 返回：如果以反向遍历列表，列表迭代器有多个元素，则返回 true。previousE previous()返回列表中的前一个元素。可以重复调用此方法来迭代列表，或混合调用 next 来前后移动（注意交替调用 next 和 previous 将重复返回相同的元素）。 返回：列表中的上一个元素。 抛出： NoSuchElementException - 如果没有可迭代的上一个元素。previousIndexint previousIndex()返回对 previous 的后续调用所返回元素的索引。（如果列表迭代器在列表的开始，则返回 -1）。 返回：对 previous 的后续调用所返回元素的索引，如果列表迭代器在列表的开始，则返回 -1。

建议你remove掉然后重新add，因为元素改了hashcode也改了，这样在hashset内部的位置要重新计算，你要是直接改元素的内容元素在hashset内部的位置不会变，后面使用的时候就会出问题

舍本逐末 知道就好宏观把握

foreach语句是由iterator实现的，正如你所说，他们的不同之处就在于remove()方法上。一般调用删除方法都是集合的方法，例如：Listlist=newArrayList();list.add(...);list.remove(...);但是，如果在循环的过程中调用集合的remove()方法，就会导致循环出错，例如：for(inti=0;i<list.size();i++){list.remove(...);}循环过程中list.size()的大小变化了，就导致了错误。所以，如果你想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。如果你想了解的更透彻，可以查看一下原码，看它是怎么实现的。因为foreach语句是由iterator语句实现的，所以如果你在循环中删除某个元素时，应该用iterator的remove()方法，可是这时你又没有iterator对象，怎么调用呢？所以，这种情况下，一般还是用iterator来循环访问，并筛选删除。说白了，foreach就是为了让用iterator循环访问的形式看着更好看，写起来更方便。但如有删除操作，当然还是用它原来的形式了。

哪句啊？？

是一个接口，，，，AbstractList（list的父类）包含一个iterator()的方法，就是返回一个iterator的对象

区别：1、Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。2、Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。3、ListIterator实现了Iterator接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。

定义结构然而在前一种情况，容器承受了过多的功能，它不仅要负责自己“容器”内的元素维护（添加、删除等等），而且还要提供遍历自身的接口；而且由于遍历状态保存的问题，不能对同一个容器对象同时进行多个遍历。第二种方式倒是省事，却又将容器的内部细节暴露无遗。而迭代器模式的出现，很好的解决了上面两种情况的弊端。先来看下迭代器模式的真面目吧。迭代器模式由以下角色组成：1) 迭代器角色（Iterator）：迭代器角色负责定义访问和遍历元素的接口。2) 具体迭代器角色（Concrete Iterator）：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。3) 容器角色（Container）：容器角色负责提供创建具体迭代器角色的接口。4) 具体容器角色（Concrete Container）：具体容器角色实现创建具体迭代器角色的接口——这个具体迭代器角色与该容器的结构相关。迭代器模式的类图如下：从结构上可以看出，迭代器模式在客户与容器之间加入了迭代器角色。迭代器角色的加入，就可以很好的避免容器内部细节的暴露，而且也使得设计符合“单一职责原则”。注意，在迭代器模式中，具体迭代器角色和具体容器角色是耦合在一起的——遍历算法是与容器的内部细节紧密相关的。为了使客户程序从与具体迭代器角色耦合的困境中脱离出来，避免具体迭代器角色的更换给客户程序带来的修改，迭代器模式抽象了具体迭代器角色，使得客户程序更具一般性和重用性。这被称为多态迭代。

迭代器（Iterator）　　迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。　　Java中的Iterator功能比较简单，并且只能单向移动：　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。　　(2) 使用next()获得序列中的下一个元素。　　(3) 使用hasNext()检查序列中是否还有元素。　　(4) 使用remove()将迭代器新返回的元素删除。　　Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。迭代器应用： list l = new ArrayList(); l.add("aa"); l.add("bb"); l.add("cc"); for (Iterator iter = l.iterator(); iter.hasNext();) { String str = (String)iter.next(); System.out.println(str); } /*迭代器用于while循环 Iterator iter = l.iterator(); while(iter.hasNext()){ String str = (String) iter.next(); System.out.println(str); } */

Iterator 迭代器Iterable 可迭代。迭代器可以迭代，可以迭代的是迭代器。可迭代类中封装了Iterator接口，只要实现了Iterable接口的类，就可以使用Iterator迭代器了。

java提供了很多集合类，而迭代器模式就是提供一种方法，顺序访问聚集的对象。而又不暴露该集合的内部表示。java中使用迭代器模式实现Iterator接口，用于对集合类的访问（遍历），新增，删除等操作。而Iterator接口只是java提供的一种抽象迭代器。对于具体迭代器，在不同集合类中实现自定义的具体迭代器；这样避免暴露了各个集合类中内部设计的结构和操作。 源码：ArrayList中的具体迭代器Itr 而Iterable的作用就是获取一个新的迭代器，每次获取的都是cursor重新开始的迭代器。而Iterable接口的iterator()方法的作用就是每次专门创建一个新的迭代器。 源码：ArrayList实现的Iterable接口 区别就是Iterable接口是专门创建新的迭代器的，Iterator接口是一个专门设计迭代器的。

Java中的Iterator功能比较简单，并且只能单向移动：(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。2(2) 使用next()获得序列中的下一个元素。3(3) 使用hasNext()检查序列中是否还有元素。4(4) 使用remove()将迭代器新返回的元素删除。

迭代器，可用于遍历STL set,map,vector等

迭代器list<int> lst;for(list<int>::iterator i = lst.begin(); i != lst.end(); i++) printf("%d", *i);iterator本质就是一个指针，和下面类似char s[] = "hello";for(char* p = s; *p != ""; p++) printf("%c", *p);

有时间你去看看Iterator接口的源代码是怎么写的。

【答案】：Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的迭代方法。迭代器可以在迭代的过程中删除底层集合的元素。

iterator(迭代)一般很少直接使用, 但是却是很常用很重要的功能. 例如 : 对象的扩展运算符（...）内部其实是调用了 Iterator 接口。 在es6 中统一了遍历的接口 Iterator，Iterator 接口的目的，就是为所有数据结构，提供了一种统一的访问机制，即for...of循环。 字符串也可以使用扩展运算符 rest运算符, 与扩展运算符是逆运算 扩展运算符：数组=>分割序列 rest运算符：分割序列=>数组 rest可以代替arguments变量 回到主题, 迭代 Symbol.iterator 为每一个对象定义了默认的迭代器。 当需要对一个对象进行迭代时（比如开始用于一个 for..of 循环中），它的 @@iterator 方法都会在不传参情况下被调用，返回的 迭代器 用于获取要迭代的值。 一些内置类型拥有默认的迭代器行为，其他类型（如 Object ）则没有。下表中的内置类型拥有默认的 @@iterator 方法： 更多信息请参见 迭代协议 。 js中对象分为可迭代和不可迭代 如果是可迭代哪它就会有一个[Symbol.iterator] 函数 这个函数就是对象的迭代器函数，如用for of 如果遍历的对象没有这个迭代方法那么就会报错. for of 传入的是可迭代对象,但是如何吧一个不可迭代的对象变为可迭代的对象呢！很简单就是自己写一个[Symbol.iterator]函数。 你以为迭代就这么简单的结束了吗?现在再讲一个新东西 yield . yield是ES6的新关键字，使生成器函数执行暂停，yield关键字后面的表达式的值返回给生成器的调用者。它可以被认为是一个基于生成器的版本的return关键字。 . yield关键字实际返回一个IteratorResult（迭代器）对象，它有两个属性，value和done，分别代表返回值和是否完成。 . yield无法单独工作，需要配合generator(生成器)的其他函数，如next，懒汉式操作，展现强大的主动控制特性。 用 yield 自定义一个迭代器 function* () {} 这种函数名字叫 generator函数, 生成器函数, 下一篇再重点讲这个哈.

Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。 x0dx0ax0dx0a 例如，如果没有使用Iterator，遍历一个数组的方法是使用索引： x0dx0ax0dx0afor(int i=0; i

循环器(iterator)的功能循环器（迭代器）是对象的容器，包含有多个对象。通过调用循环器的next()方法 (__next__()方法，在Python 3.x中)，循环器将依次返回一个对象。直到所有的对象遍历穷尽，循环器将举出StopIteration错误。在for i in iterator结构中，循环器每次返回的对象将赋予给i，直到循环结束。使用iter()内置函数，我们可以将诸如表、字典等容器变为循环器。比如for i in iter([2, 4, 5, 6]):print(i)>>> a=iter([2, 4, 5, 6])>>> while True: next(a)标准库中的itertools包提供了更加灵活的生成循环器的工具。这些工具的输入大都是已有的循环器。另一方面，这些工具完全可以自行使用Python实现，该包只是提供了一种比较标准、高效的实现方式。这也符合Python“只有且最好只有解决方案”的理念。# import the toolsfrom itertools import *无穷循环器count(5, 2) #从5开始的整数循环器，每次增加2，即5, 7, 9, 11, 13, 15 ...cycle("abc") #重复序列的元素，既a, b, c, a, b, c ...repeat(1.2) #重复1.2，构成无穷循环器，即1.2, 1.2, 1.2, ...repeat也可以有一个次数限制:repeat(10, 5) #重复10，共重复5次

迭代器（Iterator）迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。Java中的Iterator功能比较简单，并且只能单向移动：(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。(2) 使用next()获得序列中的下一个元素。(3) 使用hasNext()检查序列中是否还有元素。(4) 使用remove()将迭代器新返回的元素删除。Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。