iterator

函数reversed不返回列表，而是返回一个迭代器。可使用list将返回的对象转换为列表。x = [1,2,3]number = reversed(x)　　# error <list_reverseiterator object at 0x03BE7A10>number = list(reversed(x))　　>> [3,2,1]

我一般用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

迭代器（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

是指向STRING的迭代器吧。。其实和指针的概念是一样的。。也是一种类型。比指针使用方便多了，功能多。很好的安全保障。。STL很多地方都需要使用ITERATOR的。想想就知道它的功能很强大的了。不多只适用于STL

it.size（）

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

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

其实是靠 hashcode 和equals 方法来控制的详情参照下面链接 很详细的http://hi.baidu.com/walkingz/blog/item/300ffc35463a37375bb5f5b1.html

it相当于是个指针，每次.next()都向下拨打。所以依次输出

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，就解决了

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，不然别用这个烂玩意。直接当数组用，多方便啊。

java ITerable和Iterator的区别如下：1.Iterator是迭代器类，而Iterable是为了只要实现该接口就可以使用foreach，进行迭代.Iterable中封装了Iterator接口，只要实现了Iterable接口的类，就可以使用Iterator迭代器了。2.集合Collection、List、Set都是Iterable的实现类，所以他们及其他们的子类都可以使用foreach进行迭代。3.Iterator中和核心的方法next(),hasnext(),remove(),都是依赖当前位置，如果这些集合直接实现Iterator，则必须包括当前迭代位置的指针。当集合在方法间进行传递的时候，由于当前位置不可知，所以next()之后的值，也不可知。而当实现Iterable则不然，每次调用都返回一个从头开始的迭代器，各个迭代器之间互不影响。

可以用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内部的位置不会变，后面使用的时候就会出问题

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

Iterator和ListIterator主要区别在以下方面：1. ListIterator有add()方法，可以向List中添加对象，而Iterator不能2. ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。3. ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。4. 都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。

是一个接口，，，，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); } */

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中插入和删除元素。

Iterator iterator = list.iterator();Object first = null;Object last = null;int count = 0;while(iterator.hasNext()) {count++;Object temp = iterator.next();if(count==1) {first = temp;}else {if(!iterator.hasNext()) {//最后一个元素last = temp;}}}之后对first、last处理，之后的代码用户可根据自己的需求进行处理。扩展资料：迭代器是一种模式、详细可见其设计模式，可以使得序列类型的数据结构的遍历行为与被遍历的对象分离，即我们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就可以遍历这个对象的内部。Iterable：实现这个接口的集合对象支持迭代，是可以迭代的。实现了这个可以配合foreach使用Iterator：迭代器，提供迭代机制的对象，具体如何迭代是这个Iterator接口规范的。Iterator接口包含三个方法：hasNext，next，remove。参考资料来源：百度百科-迭代器

Iterator（迭代器）是一个接口，它的作用就是遍历容器的所有元素。 Iterator iter = list.iterator(); // 注意iterator，首字母小写 iterator是为了实现对Java容器（collection）进行遍历功能的一个接口。 在iterator实现了Iterator接口后，相当于把一个Collection容器的所有对象，做成一个线性表（List），而iterator本身是一个指针，开始时位于第一个元素之前。 判断 iterator 内是否存在下1个元素，如果存在，返回true，否则返回false。（注意，这时上面的那个指针位置不变） 返回 iterator 内下1个元素，同时上面的指针向后移动一位。 故，如果不断地循环执行next()方法，就可以遍历容器内所有的元素了。 删除 iterator 内指针的前1个元素，前提是至少执行过1次next(); (这个方法不建议使用，建议使用容器本身的romove 方法) 遍历1个ArrayList 和Linklist是十分容易的，遍历1个Tree容器也不难，但是实现机制是完全不同，而遍历1个Set容器就无从下手了。 所以Java设计了Iterator 这个接口，分别让各种容器自己去重写里面的hasNext()和next()方法。 不用关心各种容器的遍历机制，只要使用Iterator，会让人觉得各种容器的遍历方法都是一样的，这就是Java接口的重要意义。 在Java的各种容器中，例如ArrayList，HashSet等，并没有直接实现Iterator这个接口。所以ArrayList，HashSet容器内是没有hasnext()，next()的方法的，而是iterator() 这个方法，返回1个实现了Iterator接口的iterator对象。

生产者物价指数（PPI）：生产者物价指数主要的目的在衡量各种商品在不同的生产阶段的价格变化情形。一般而言，商品的生产分为三个阶段：一、 原始阶段：商品尚未做任何的加工；二、 中间阶段：商品尚需作进一步的加工；三、 完成阶段：商品至此不再做任何加工手续。 PPI是衡量工业企业产品出厂价格变动趋势和变动程度的指数，是反映某一时期生产领域价格变动情况的重要经济指标，也是制定有关经济政策和国民经济核算的重要依据。目前，我国PPI的调查产品有4000多种（含规格品9500多种），覆盖全部39个工业行业大类，涉及调查种类186个。 根据价格传导规律,PPI对CPI有一定的影响。PPI反映生产环节价格水平,CPI反映消费环节的价格水平。整体价格水平的波动一般首先出现在生产领域,然后通过产业链向下游产业扩散,最后波及消费品。产业链可以分为两条：一是以工业品为原材料的生产,存在原材料→生产资料→生活资料的传导。另一条是以农产品为原料的生产,存在农业生产资料→农产品→食品的传导。在中国，就以上两个传导路径来看，目前第二条,即农产品向食品的传导较为充分,，2006年以来粮价上涨是拉动CPI上涨的主要因素。但第一条,即工业品向CPI的传导基本是失效的。 由于CPI不仅包括消费品价格，还包括服务价格，CPI与PPI在统计口径上并非严格的对应关系，因此CPI与PPI的变化出现不一致的情况是可能的。CPI与PPI持续处于背离状态,这不符合价格传导规律。价格传导出现断裂的主要原因在于工业品市场处于买方市场以及政府对公共产品价格的人为控制。 在不同市场条件下，工业品价格向最终消费价格传导有两种可能情形：一是在卖方市场条件下,成本上涨引起的工业品价格(如电力、水、煤炭等能源、原材料价格)上涨最终会顺利传导到消费品价格上；二是在买方市场条件下，由于供大于求，工业品价格很难传递到消费品价格上，企业需要通过压缩利润对上涨的成本予以消化，其结果表现为中下游产品价格稳定，甚至可能继续走低,企业盈利减少。对于部分难以消化成本上涨的企业，可能会面临破产。可以顺利完成传导的工业品价格(主要是电力、煤炭、水等能源原材料价格)目前主要属于政府调价范围。在上游产品价格(PPI)持续走高的情况下，企业无法顺利把上游成本转嫁出去，使最终消费品价格(CPI)提高，最终会导致企业利润的减少。 PPI通常作为观察通货膨胀水平的重要指标。由于食品价格因季节变化加大，而能源价格也经常出现意外波动，为了能更清晰地反映出整体商品的价格变化情况，一般将食品和能源价格的变化剔除，从而形成“核心生产者物价指数”，进一步观察通货膨胀率变化趋势。 在美国，美国生产者物价指数的资料搜集由美国劳工局负责，他们以问卷的方式向各大生产厂商搜集资料，搜集的基准月是每个月包含13日在内该星期的2300种商品的报价，再加权换算成百进位形态，为方便比较，基期定为1967年。一般而言，当生产者物价指数增幅很大而且持续加速上升时，该国央行相应的反应是采取加息对策阻止通货膨胀快速上涨，则该国货币升值的可能性增大；反之亦然。 真正的经济学家注重PPI而媒体注重core PPI，将食物及能源去除后的，称为“核心PPI”（Core PPI）指数，以正确判断物价的真正走势---这是由于食物及能源价格一向受到季节及供需的影响，波动剧烈。core PPI短期内 会产生误导作用。 如何计算，PPI主要着眼于工业，矿业，原料，半成品的价格，目前也加进了服务业，不过比重较小。美劳工部会在25000多企业做调查，得出产品价格，根据行业不同和在经济中的比重，分配比例和权重。 PPI能够反映生产者获得原材料的价格波动情况，推算预期CPI，从而估计通胀风险。 总之，PPI上升不是好事，如果生产者转移成本，终端消费品价格上扬，通胀上涨。如果不转移，企业利润下降，经济有下行风险