iterator _生活经验

JAVA中Iterator的具体作用？提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。

，也就是说Collection接口的实现类，都可以调用iterator方法，进行内部元素的访问，虽然容器的实现有多种，比如有list ，有set，list中有链表，也有普通的list，但是你不需要管这些细节，只要你用iterator这个方法，就可以循环的调用内部的元素，是设计模式的一种，这些是我的理解，具体官方的解释比较长，我也给你拿出来，有精力，你可以看下，美丽的分割线

----------------------------------------------------------------------------------------------------------------------
迭代器模式(Iterator pattern)
一、引言
迭代这个名词对于熟悉Java的人来说绝对不陌生。我们常常使用JDK提供的迭代接口进行java collection的遍历：
Iterator it = list.iterator();
while(it.hasNext()){
//using “it.next();”do some businesss logic
}
而这就是关于迭代器模式应用很好的例子。
二、定义与结构
迭代器（Iterator）模式，又叫做游标（Cursor）模式。GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。
从定义可见，迭代器模式是为容器而生。很明显，对容器对象的访问必然涉及到遍历算法。你可以一股脑的将遍历方法塞到容器对象中去；或者根本不去提供什么遍历算法，让使用容器的人自己去实现去吧。这两种情况好像都能够解决问题。
然而在前一种情况，容器承受了过多的功能，它不仅要负责自己“容器”内的元素维护（添加、删除等等），而且还要提供遍历自身的接口；而且由于遍历状态保存的问题，不能对同一个容器对象同时进行多个遍历。第二种方式倒是省事，却又将容器的内部细节暴露无遗。
而迭代器模式的出现，很好的解决了上面两种情况的弊端。先来看下迭代器模式的真面目吧。
迭代器模式由以下角色组成：
1) 迭代器角色（Iterator）：迭代器角色负责定义访问和遍历元素的接口。
2) 具体迭代器角色（Concrete Iterator）：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。
3) 容器角色（Container）：容器角色负责提供创建具体迭代器角色的接口。
4) 具体容器角色（Concrete Container）：具体容器角色实现创建具体迭代器角色的接口——这个具体迭代器角色于该容器的结构相关。
迭代器模式的类图如下：

从结构上可以看出，迭代器模式在客户与容器之间加入了迭代器角色。迭代器角色的加入，就可以很好的避免容器内部细节的暴露，而且也使得设计符号“单一职责原则” 。
注意，在迭代器模式中，具体迭代器角色和具体容器角色是耦合在一起的——遍历算法是与容器的内部细节紧密相关的。为了使客户程序从与具体迭代器角色耦合的困境中脱离出来，避免具体迭代器角色的更换给客户程序带来的修改，迭代器模式抽象了具体迭代器角色，使得客户程序更具一般性和重用性。这被称为多态迭代。
三、举例
由于迭代器模式本身的规定比较松散，所以具体实现也就五花八门。我们在此仅举一例，根本不能将实现方式一一呈现。因此在举例前，我们先来列举下迭代器模式的实现方式。
1．迭代器角色定义了遍历的接口，但是没有规定由谁来控制迭代。在Java collection的应用中，是由客户程序来控制遍历的进程，被称为外部迭代器；还有一种实现方式便是由迭代器自身来控制迭代，被称为内部迭代器。外部迭代器要比内部迭代器灵活、强大，而且内部迭代器在java语言环境中，可用性很弱。
2．在迭代器模式中没有规定谁来实现遍历算法。好像理所当然的要在迭代器角色中实现。因为既便于一个容器上使用不同的遍历算法，也便于将一种遍历算法应用于不同的容器。但是这样就破坏掉了容器的封装——容器角色就要公开自己的私有属性，在java中便意味着向其他类公开了自己的私有属性。
那我们把它放到容器角色里来实现好了。这样迭代器角色就被架空为仅仅存放一个遍历当前位置的功能。但是遍历算法便和特定的容器紧紧绑在一起了。
而在Java Collection的应用中，提供的具体迭代器角色是定义在容器角色中的内部类。这样便保护了容器的封装。但是同时容器也提供了遍历算法接口，你可以扩展自己的迭代器。
好了，我们来看下Java Collection中的迭代器是怎么实现的吧。
//迭代器角色，仅仅定义了遍历接口
public interface Iterator {
boolean hasNext();
Object next();
void remove();
}
//容器角色，这里以List为例。它也仅仅是一个接口，就不罗列出来了
//具体容器角色，便是实现了List接口的ArrayList等类。为了突出重点这里指罗列和迭代器相关的内容
//具体迭代器角色，它是以内部类的形式出来的。AbstractList是为了将各个具体容器角色的公共部分提取出来而存在的。
public abstract class AbstractList extends AbstractCollection implements List {
……
//这个便是负责创建具体迭代器角色的工厂方法
public Iterator iterator() {
return new Itr();
}
//作为内部类的具体迭代器角色
private class Itr implements Iterator {
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public Object next() {
checkForComodification();
try {
Object next = get(cursor);
lastRet = cursor++;
return next;
} catch(IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch(IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
至于迭代器模式的使用。正如引言中所列那样，客户程序要先得到具体容器角色，然后再通过具体容器角色得到具体迭代器角色。这样便可以使用具体迭代器角色来遍历容器了……
四、实现自己的迭代器
在实现自己的迭代器的时候，一般要操作的容器有支持的接口才可以。而且我们还要注意以下问题：
在迭代器遍历的过程中，通过该迭代器进行容器元素的增减操作是否安全呢？
在容器中存在复合对象的情况，迭代器怎样才能支持深层遍历和多种遍历呢？
以上两个问题对于不同结构的容器角色，各不相同，值得考虑。
五、适用情况
由上面的讲述，我们可以看出迭代器模式给容器的应用带来以下好处：
1) 支持以不同的方式遍历一个容器角色。根据实现方式的不同，效果上会有差别。
2) 简化了容器的接口。但是在java Collection中为了提高可扩展性，容器还是提供了遍历的接口。
3) 对同一个容器对象，可以同时进行多个遍历。因为遍历状态是保存在每一个迭代器对象中的。
由此也能得出迭代器模式的适用范围：
1) 访问一个容器对象的内容而无需暴露它的内部表示。
2) 支持对容器对象的多种遍历。
3) 为遍历不同的容器结构提供一个统一的接口（多态迭代）。

JAVA中Iterator的具体作用？List list = new ArrayList();for (Iterator iter = list.iterator(); iter.hasNext();) { String str = iter.next();}迭代器呀，上面就是用来遍历List的用法示例
JAVA中Iterator的具体作用？迭代器（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中插入和删除元素。

java中为什么要使用Iterator？Iterator的用途是什么？Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。

例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：

for(int i=0; i<array.size(); i++) { ... get(i) ... }
而访问一个链表（LinkedList）又必须使用while循环：

while((e=e.next())!=null) { ... e.data() ... }
以上两种方法客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。

更恐怖的是，如果以后需要把ArrayList更换为LinkedList，则原来的客户端代码必须全部重写。

为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：

for(Iterator it = c.iterater(); it.hasNext(); ) { ... }
奥秘在于客户端自身不维护遍历集合的"指针" ，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。

客户端从不直接和集合类打交道，它总是控制Iterator ，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。

呵呵，借点别人的东西，希望对你有用

JAVA中Iterator的具体作用？迭代器，例如hadoop中
Iterable value；//value实际上已经在之前给过值，这是说明类型
Iterator it=value.iterator();
int sum=0;
Map map=new HashMap();
String text="";
while(it.hasNext()){
text=it.next().toString();
if(map.containsKey(text)){
sum=sum+1;
}else {
map.put(text, 1);
}
}
String word=key.toString()+map.get("text")+sum;
context.write(new Text(key), new Text(word));

Iterator<E>中的 E 表示什么？这个是一个泛型的迭代器，E代表你放入的object，你放的dog类型，iterator中就都是dog类型

java中的Iterator<E>的问题用Iterator模式实现遍历集合
Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。
例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：
for(int i=0; i<array.size(); i++) { ... get(i) ... }
而访问一个链表（LinkedList）又必须使用while循环：
while((e=e.next())!=null) { ... e.data() ... }
以上两种方法客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。
更恐怖的是，如果以后需要把ArrayList更换为LinkedList，则原来的客户端代码必须全部重写。
为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：
for(Iterator it = c.iterater(); it.hasNext(); ) { ... }
奥秘在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。
客户端从不直接和集合类打交道，它总是控制Iterator ，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。
首先看看java.util.Iterator接口的定义：
public interface Iterator {boolean hasNext();Object next();void remove();}
依赖前两个方法就能完成遍历，典型的代码如下：
for(Iterator it = c.iterator(); it.hasNext(); ) {Object o = it.next();// 对o的操作...}
在JDK1.5中，还对上面的代码在语法上作了简化：
// Type是具体的类型，如String 。for(Type t : c) {// 对t的操作...}
每一种集合类返回的Iterator具体类型可能不同， Array可能返回ArrayIterator，Set可能返回SetIterator，Tree可能返回TreeIterator ，但是它们都实现了Iterator接口，因此，客户端不关心到底是哪种Iterator，它只需要获得这个Iterator接口即可，这就是面向对象的威力。

若还需要具体的介绍Iterator，到我空间看看吧

java Iterator<E>的问题java.util包里关于List有很多的对应的实现，Iterator是为了满足遍历的需求写的一个接口。因为相关的内容很多，而且大体都是一个模式，所以我举例说明。

在你这里采用了ArrayList来实例化一个List，所以对应的Iterator接口是在ArrayList里实现的。
我们可以找一下jdk源代码：
public class ArrayList extends AbstractList
AbstractList extends AbstractCollection
AbstractCollection implements Collection
Collection extends Iterable

终于找到了这个，我们确定了， ArrayList对于Iterable的实现是在AbstractCollection这一层实现了Iterable接口。而这个接口的内容是：public interface Iterable {

/**
* Returns an iterator over a set of elements of type T.
*
* @return an Iterator.
*/
Iterator iterator();
}
具体的实现在ArrayList这个类里，
private class Itr implements Iterator
你可以找源代码看一下，这个内部类实现了Iterator的所有内容。

到这里，你肯定已经明白了，实际上并不是没有实现，只是实现的过程比较曲折了一些。

这里，JDK在实现上采用了Iterator模式，这个模式的大体意义是让被遍历体与遍历的具体实现分离，只要实现Iterable接口即可通过得到一个Iterator来完成遍历。具体的内容你可以上网再搜搜看。

关于Enumeration和Iterator的区别．比较：
1.Enumeration 枚举接口其实是一个比 Iterator 迭代器接口更早期的枚举集合中的元素的接口。
2.Enumeration 虽然可能过时而被 Iterator 替代，但很多 servlet 还用到，所以还有学习的必要。
3.迭代器允许调用方利用定义良好的语义在迭代期间从迭代器所指向的集合移除元素。
4.方法名称得到了改进。

枚举（Enumeration）接口是从以前版本遗留下来。在下面依次介绍Enumeration 和每一种从以前版本遗留下来的类。
Enumeration接口定义了可以对一个对象的类集中的元素进行枚举（一次获得一个）的方法。这个接口尽管没有被摈弃，但已经被Iterator所替代。Enumeration对新程序来说是过时的。然而它仍被几种从以前版本遗留下来的类（例如Vector和Properties）所定义的方法使用，被几种其他的API类所使用以及被目前广泛使用的应用程序所使用。
Enumeration指定下面的两个方法：
boolean hasMoreElements()
Object nextElement()
执行后，当仍有更多的元素可提取时，hasMoreElements()方法一定返回true 。当所有元素都被枚举了，则返回false 。nextElement()方法将枚举中的下一个对象做为一个类属 Object的引用而返回。也就是每次调用nextElement()方法获得枚举中的下一个对象。调用例程必须将那个对象置为包含在枚举内的对象类型。
对于Enumeration可以以Vector为例
Vector里有很多对象，如果你要查看其中的所有对象，一个办法是用Vector的get(int index)方法，不过这样效率比较低，另外一个方法是用Vector的elements()方法返回一个Enumeration对象，用 Enumeration的hasMoreElements()方法向下移动并判断当前位置是否有对象，有则用nextElement()方法返回这个对象
例如, 打印 vector v中的所有对象:
Enumeration e = v.elements()
while(e.hasMoreElements() )
{
System.out.println(e.nextElement());
}
另外还有个Iterator接口，和Enumeration是差不多的，不过名称比较短，通常推荐用Iterator
对集合进行迭代的迭代器。迭代器代替了 Java Collections Framework 中的 Enumeration 。Collections 接口中定义了 iterator 方法，用于返回在此 collection 的元素上进行迭代的迭代器。

Iterator是一个集合的迭代器,通过Iterator访问接口就就不用关心集合的实现.
Iterator接口中定义了三个方法:
1.hasNext()
是否还有下一个元素.
2.next()
返回下一个元素.
3.remove()
删除当前元素.
只定义了简单的三个方法,这里要注意几点:
1)Iterator和Enumeration的区别
Iterator是用来替代Enumeration的,Enumeration中只定义了两个方法,不具备删除功能.
2)调用next()方法后才可以调用remove()方法,而且每次调用next()后最多只能调用一次remove()方法,否则抛出IllegalStateException异常.

接口 Iterator<E>能被在定义类实现吗？例如： public class Person implement Iterator{ } 求教!!!!!!可以，需要重写Iterator的几个方法hasNext,next,remove;
你自己试试

Java iterator()和next()原理用法如果使用 Iterator 来遍历集合中元素，一旦不再使用 List 转而使用 ‍TreeSet 来组织数据，那遍历元素的代码不用做任何修改，如果使用 for 来遍历，那所有遍历此集合的算法都得做相应调整。

比如以后你的代码改了， list不在是list接口了，而是set接口（没有get(i)方法），
这时你的代码改动就大了，for里面全部要重写，而你老大的代码几乎不用任何修改，当然这也牺牲了部分性能‍‍

参考资料：http://bbs.csdn.net/topics/250025827

*****************************************希望帮助到你！************************************************
如果我的回答对你有帮助，
请点击我的回答下方【选为满意答案】按钮
谢谢！

java中iterator()方法详解你要问的是collection中的iterator()函数，还是Iterator迭代器啊。

JAVA中Iterator方法中有两种取值方法，例如Iterator<Student> it = list.iterator();Iterator由集合类通过工厂方法生成，方法中记录的存取方式有两种，一种是顺序存储，另一个是链接存储。如果你用for（int i）【这里比如for中的变量是i】然后get，i的值越就越慢（因为对于越往后面的值他都要统统找一边，知道找到那个下标为i的），但是用next就不一样，不后你的值有多大多深，他的next指针永远指向当前位置的下一个。比如你要找第1W个的那个值，你用for到9999的时候（9999之前的所有消耗暂且忽略不算）准备找第10000个了，现在确定是要找下标为10000的。虽然现在到了9999，但是他还是要从头找，如果是next，因为现在已经到了9999，而他的下一个刚好是10000，就很快。给你个例子，放了10层书，我现在你找到了第9层数数学，我要第十层的那本书，第一种的话，你已然要从头开始1，2，3层的数到第10层，但是next的话，你就知道哦，下一个就是我要的。（之前的那个10是用其他外部变量循环的来的，next就迭代器内部的）水平有限，不知道说的对不对。我是这样理解的。呵呵你应该这样问，集合的get方法遍历值和用集合的迭代器遍历值，他们的利与弊。

关于java iterator的next()方法的用法Flight flight = (Flight)iterator.next();//要强制类型转换一下，因为iterator中的元素都是Object型的。

java的collection接口中的iterator方法问题。Collection接口实现的是Iterable接口，不是Iterator接口，Collection接口中定义的是Iterator接口类型返回值的方法，目的是获得Iterator的迭代器，用来快速遍历用的，我觉得你是有点想不通，为什么要定义一个接口类型的变量这个问题是吗？这就有点像接口引用实现类的作用这个问题，目的是返回一个接口类型的实现类对象，好比是下面的代码：你仔细看注释哈哈哈
//接口
interface Smoke{
public abstract void smoking();
}
class Student implements Smoke{
@Override
public void smoking() {
System.out.println("课下吸口烟，赛过活神仙");
}
}
//测试类
public class Test {
public static void main(String[] args) {
//调用method方法，获取返回的会吸烟的对象
Smoke s = method();
//通过s变量调用smoking方法,这时实际调用的是Student对象中的smoking方法s.smoking();
}
//定义一个方法method，用来获取一个具备吸烟功能的对象，并在方法中完成吸烟者的创建
public static Smoke method(){
Smoke sm = new Student();
return sm;
}
}

Java中的Iterator有什么作用？【iterator】foreach 也是通过使用集合的 iterator方法获取迭代器来实现的，因为使用迭代器代码比较多，所以sun 在sdk 5.0 中才增加了 foreach 的实现，为了方便集合的遍历

在Java中的迭代器有什么作用?。?/h3>由于Java中数据容器众多，而对数据容器的操作在很多时候都具有极大的共性，于是Java采用了迭代器为各种容器提供公共的操作接口。使用Java的迭代器iterator可以使得对容器的遍历操作完全与其底层相隔离，可以到达极好的解耦效果。下面是一个使用迭代器遍历一个序列化和非序列化容器的例子。
mport java.util.*;

publicclass TestIterator {

public static void main(String[] args) {

//创建一个list 它是一个序列化的数据
List list=new ArrayList();
//创建一个map ，它是一个非序列化的数据
Map map=new HashMap();

for(int i=0;i<10;i++){
//向容器中添加数据
list.add(new String("list"+i) );

map.put(i, new String("map"+i));

}
//序列化了的数据创建迭代器。
Iterator iterList= list.iterator();//List接口实现了Iterable接口
//进行遍历如果容器中有下一个数据，就获取下一个数据并打印出来

while(iterList.hasNext()){
String strList=(String)iterList.next();

System.out.println(strList.toString());

}
//创建非序列化数据的迭代器，要先将其序列化
Iterator iterMap=map.entrySet().iterator();
//进行遍历如果容器中有下一个数据，就获取下一个数据并打印出来
while(iterMap.hasNext()){

Map.Entry strMap=(Map.Entry)iterMap.next();

System.out.println(strMap.getValue());

}

}

}
这些都是一些基础的Java知识，在秒秒学的网站上查看资料。

JAVA中Iterator的具体作用？你说的没有错,iterator有hasNext()方法,返回是否还有没有访问的元素,next()则是返回下一个元素,这样对于需要遍历的地方,你就不需要知道元素的个数了.
而且iterator支持泛型,如
ArrayList list=new ArrayList ();
list.add("I");
list.add("Love");
list.add("You");
//注意对list修改完后，再取迭代器。不然会引发ConcurrentModificationException
//迭代器
Iterator iter=list.iterator();

while(iter.hasNext())
System.out.println(iter.next()); //next()取得直接是String类型，不需要类型转换了。(JDK1.5以上)
//ArrayList实现了Iterable接口，因此可以用for-each循环遍历(JDK1.5以上)
for(String str:list)
System.out.println(str);

-------
你把它理解成数据结构中链表的那个next,就是一个线索。把容器中的各个元素穿起来。
你自己的类型也可以实现iterable接口，就可以迭代了。也可以用
foreach循环遍历了。

关于java iterator的next()的用法/**
* @author eatonfang
* @version 1.0
*
*/
public class Test {

/**
* @param args
*/
public static void main(String[] args) {
List test = new ArrayList();
test.add("a");
test.add("b");
test.add("c");
Iterator iterator = test.iterator();
while (iterator.hasNext()) {
String temp = iterator.next();
System.out.println(temp);
}
// result
//a
//b
//c
}
}

JAVA iterator 迭代器模式的next() 的问题求高手回答谢谢！真诚求学在线等。关于你的疑问，请参考我的学习笔记吧。
hasNext、next方法：迭代器用于遍历集合元素。获取迭代器可以使用Collection定义的方法：Iterator iterator()
迭代器Iterator 本身是一个接口，集合在重写Collection的iterator()方法时利用内部类提供了迭代器的实现。Iterator提供了统一的遍历集合元素的方式，其提供了用于遍历集合的两个方法：boolean hasNext()判断集合是否还有元素可以遍历。
E next() 返回迭代的下一个元素。
每一种集合的实现类都是各自的迭代器实现，不用关心具体迭代器的类型，只将他们当作迭代器用于遍历集合元素即可。应当遵循“问-取-删”模式，适用于while循环。
Iteratorit = 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();
}
}

Java iterator()和next()原理是什么？用法是什么？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);
}
*/

listiterator的next()方法第一个问题你的理解是对的，还有next()和nextIndex()都会使内部索引增加1，你把上面的it.next()那句注释掉就会发现it.nextIndex()会输出0.

list和iterator的区别list和iterator的区别是Iterator可以使用JCS，而List不能。JCS的介绍：CS(Java Caching System)是一个对象Cache，它可以把Java对象缓存起来，提高那些访问频率很高的Java对象的存取效率。JCS是按照对象的唯一标示来存取对象的，比如说可以按照对象的hashCode来存取。对于Hibernate来说，可以利用JCS来缓存查询结果，这样当下次访问同样的数据，就无须去数据库?。苯哟覬CS中取出来，加快了查询速度。当Hibernate使用List或者Iterator方式来第一次读取数据的时候，JCS是空的，此时不管是List方式还是Iterator方式都会往JCS里面填充查询出来的持久对象。从JCS中取数据是按照对象的唯一标示来存取的，而对于PO持久对象来说，唯一标示就是主键，因此Hibernate首先必须获得主键列表，然后根据主键列表挨个判定，看这个持久对象究竟是在JCS里面还是在数据库里面，假如在JCS里面，那么按照主键?。偃缭谑菘?nbsp;，那么发送sql取。举例：（1）在用Query方法查询的时候，通过HQL语句来得到Query对象，并对Query对象进行操作，首先是用list方法获取到Query的List集合并输出public void listQuery() {Configuration configuration = new Configuration().configure();SessionFactory factory = configuration.buildSessionFactory();Session session = factory.openSession();Query query = session.createQuery("from Customers");List list = query.list();for(Customers entity:list){System.out.println(entity.toString());}}或者如下代码：输出的结果为：List的执行sql语句为：Hibernate: select customers0_.id as id0_, customers0_.realName as realName0_, customers0_.pass as pass0_, customers0_.sex as sex0_, customers0_.petName as petName0_, customers0_.email as email0_, customers0_.rdate as rdate0_ from customers customers0_cn.csdn.products.domain.Customers@5bf624（2）通过Query得到Query的对象，并用iterator迭代器输出public void iterateQuery(){Configuration configuration = new Configuration().configure();SessionFactory factory = configuration.buildSessionFactory();Session session = factory.openSession();Query query = session.createQuery("from Customers");Iterator it = query.iterate();// 遍历出来所有的查询结果while (it.hasNext()) {Customers customer = it.next();System.out.println(customer.toString());}}Iterator的执行结果：Hibernate: select customers0_.id as col_0_0_ from customers customers0_
java中Iterator和Iterable的区别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 和 iterator 的区别 javaiterator用于迭代获取集合类中的元素，主要方法hasnext，next

java中为什么要使用Iterator，或者Iterator的用途是什么Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。

例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：

for(int i=0; i<array.size(); i++) { ... get(i) ... }
而访问一个链表（LinkedList）又必须使用while循环：

while((e=e.next())!=null) { ... e.data() ... }
以上两种方法客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。

更恐怖的是，如果以后需要把ArrayList更换为LinkedList ，则原来的客户端代码必须全部重写。

为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：

for(Iterator it = c.iterater(); it.hasNext(); ) { ... }
奥秘在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。

客户端从不直接和集合类打交道，它总是控制Iterator，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。

呵呵，借点别人的东西，希望对你有用

Iterator it = list.iterator()什么意思?应用来自：（http://hi.baidu.com/ptznet/blog/item/1c9409870f641c2bc65cc3f9.html）
迭代器模式(Iterator pattern)2007-03-30 12:52一、引言
迭代这个名词对于熟悉Java的人来说绝对不陌生。我们常常使用JDK提供的迭代接口进行java collection的遍历：
Iterator it = list.iterator();
while(it.hasNext()){
//using “it.next();”do some businesss logic
}
而这就是关于迭代器模式应用很好的例子。

二、定义与结构

迭代器（Iterator）模式，又叫做游标（Cursor）模式。GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。

从定义可见，迭代器模式是为容器而生。很明显，对容器对象的访问必然涉及到遍历算法。你可以一股脑的将遍历方法塞到容器对象中去；或者根本不去提供什么遍历算法，让使用容器的人自己去实现去吧。这两种情况好像都能够解决问题。

然而在前一种情况，容器承受了过多的功能，它不仅要负责自己“容器”内的元素维护（添加、删除等等），而且还要提供遍历自身的接口；而且由于遍历状态保存的问题，不能对同一个容器对象同时进行多个遍历。第二种方式倒是省事，却又将容器的内部细节暴露无遗。

而迭代器模式的出现，很好的解决了上面两种情况的弊端。先来看下迭代器模式的真面目吧。

迭代器模式由以下角色组成：

1) 迭代器角色（Iterator）：迭代器角色负责定义访问和遍历元素的接口。

2) 具体迭代器角色（Concrete Iterator）：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。

3) 容器角色（Container）：容器角色负责提供创建具体迭代器角色的接口。

4) 具体容器角色（Concrete Container）：具体容器角色实现创建具体迭代器角色的接口——这个具体迭代器角色于该容器的结构相关。

迭代器模式的类图如下：

从结构上可以看出，迭代器模式在客户与容器之间加入了迭代器角色。迭代器角色的加入，就可以很好的避免容器内部细节的暴露，而且也使得设计符号“单一职责原则” 。

注意，在迭代器模式中，具体迭代器角色和具体容器角色是耦合在一起的——遍历算法是与容器的内部细节紧密相关的。为了使客户程序从与具体迭代器角色耦合的困境中脱离出来，避免具体迭代器角色的更换给客户程序带来的修改，迭代器模式抽象了具体迭代器角色，使得客户程序更具一般性和重用性。这被称为多态迭代。

三、举例

由于迭代器模式本身的规定比较松散，所以具体实现也就五花八门。我们在此仅举一例，根本不能将实现方式一一呈现。因此在举例前，我们先来列举下迭代器模式的实现方式。

1．迭代器角色定义了遍历的接口，但是没有规定由谁来控制迭代。在Java collection的应用中，是由客户程序来控制遍历的进程，被称为外部迭代器；还有一种实现方式便是由迭代器自身来控制迭代，被称为内部迭代器。外部迭代器要比内部迭代器灵活、强大，而且内部迭代器在java语言环境中，可用性很弱。

2．在迭代器模式中没有规定谁来实现遍历算法。好像理所当然的要在迭代器角色中实现。因为既便于一个容器上使用不同的遍历算法，也便于将一种遍历算法应用于不同的容器。但是这样就破坏掉了容器的封装——容器角色就要公开自己的私有属性，在java中便意味着向其他类公开了自己的私有属性。

那我们把它放到容器角色里来实现好了。这样迭代器角色就被架空为仅仅存放一个遍历当前位置的功能。但是遍历算法便和特定的容器紧紧绑在一起了。

而在Java Collection的应用中，提供的具体迭代器角色是定义在容器角色中的内部类。这样便保护了容器的封装。但是同时容器也提供了遍历算法接口，你可以扩展自己的迭代器。

好了，我们来看下Java Collection中的迭代器是怎么实现的吧。
//迭代器角色，仅仅定义了遍历接口

public interface Iterator {
boolean hasNext();
Object next();
void remove();
}

//容器角色，这里以List为例。它也仅仅是一个接口，就不罗列出来了
//具体容器角色，便是实现了List接口的ArrayList等类。为了突出重点这里指罗列和迭代器相关的内容
//具体迭代器角色，它是以内部类的形式出来的。AbstractList是为了将各个具体容器角色的公共部分提取出来而存在的。

public abstract class AbstractList extends AbstractCollection implements List {
……
//这个便是负责创建具体迭代器角色的工厂方法
public Iterator iterator() {
return new Itr();
}

//作为内部类的具体迭代器角色

private class Itr implements Iterator {
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;

public boolean hasNext() {
return cursor != size();
}

public Object next() {
checkForComodification();
try {
Object next = get(cursor);
lastRet = cursor++;
return next;
} catch(IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}

public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();

try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch(IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}

final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
至于迭代器模式的使用。正如引言中所列那样，客户程序要先得到具体容器角色，然后再通过具体容器角色得到具体迭代器角色。这样便可以使用具体迭代器角色来遍历容器了……

四、实现自己的迭代器

在实现自己的迭代器的时候，一般要操作的容器有支持的接口才可以。而且我们还要注意以下问题：

在迭代器遍历的过程中，通过该迭代器进行容器元素的增减操作是否安全呢？

在容器中存在复合对象的情况，迭代器怎样才能支持深层遍历和多种遍历呢？

以上两个问题对于不同结构的容器角色，各不相同，值得考虑。

五、适用情况

由上面的讲述，我们可以看出迭代器模式给容器的应用带来以下好处：

1) 支持以不同的方式遍历一个容器角色。根据实现方式的不同，效果上会有差别。

2) 简化了容器的接口。但是在java Collection中为了提高可扩展性，容器还是提供了遍历的接口。

3) 对同一个容器对象，可以同时进行多个遍历。因为遍历状态是保存在每一个迭代器对象中的。

由此也能得出迭代器模式的适用范围：

1) 访问一个容器对象的内容而无需暴露它的内部表示。

2) 支持对容器对象的多种遍历。

3) 为遍历不同的容器结构提供一个统一的接口（多态迭代）。

迭代器是什么简介：迭代器（iterator）有时又称游标（cursor）是程序设计的软件设计模式，可在容器（container，例如链表或阵列）上遍访的接口，设计人员无需关心容器的内容。1.功能：迭代器使开发人员能够在类或结构中支持foreach迭代，而不必整个实现IEnumerable或者IEnumerator接口。只需提供一个迭代器，即可遍历类中的数据结构。当编译器检测到迭代器时，将自动生成IEnumerable接口或者IEnumerator接口的Current，MoveNext和Dispose方法。2.特点：（1）迭代器是可以返回相同类型值的有序序列的一段代码。（2）迭代器可用作方法、运算符或get访问器的代码体。（3）迭代器代码使用yieldreturn语句依次返回每个元素， yield break将终止迭代。（4）可以在类中实现多个迭代器，每个迭代器都必须像任何类成员一样有惟一的名称，并且可以在foreach语句中被客户端,代码调用如下所示：foreach(int x in SimpleClass.Iterator2){} 。（5）迭代器的返回类型必须为IEnumerable和IEnumerator中的任意一种。
C#中迭代是什么？迭代器又是什么？用最直观的说法，迭代就是指循环，迭代器是指实现该循环的一种方式，下面讲解什么叫迭代器：

迭代器是C# 2.0中的新功能，它是方法、get访问器或运算符，它使开发人员能够在类或结构中支持foreach迭代，而不必实现整个IEnumerable接口。只需提供一个迭代器，即可遍历类中的数据结构。当编译器检测到迭代器时，它将自动生成IEnumerable或IEnumerable接口的Current、MoveNext和Dispose方法。迭代器有以下特点：
迭代器是可以返回相同类型值的有序序列的一段代码；
迭代器可用作方法、运算符或get访问器的代码体；
迭代器代码使用yield return语句依次返回每个元素，yield break将终止迭代；
可以在类中实现多个迭代器，每个迭代器都必须像任何类成员一样有惟一的名称，并且可以在foreach语句中被客户端代码调用；
迭代器的返回类型必须为IEnumerable和IEnumerator中的任意一种；? 迭代器是产生值的有序序列的一个语句块，不同于有一个或多个yield语句存在的常规语句块；
迭代器不是一种成员，它只是实现函数成员的方式，理解这一点是很重要的，一个通过迭代器实现的成员，可以被其他可能或不可能通过迭代器实现的成员覆盖和重载；
迭代器块在C#语法中不是独特的元素，它们在几个方面受到限制，并且主要作用在函数成员声明的语义上，它们在语法上只是语句块而已；

什么是C++的迭代器Interator？容器就是数据结构的泛指，迭代器就是指针的泛指，可以指向元素。容器相当于一个储藏柜，里面装的许多不同的物品就像是储存的元素，比如面包、啤酒、苹果、现金。要取得各个物体就得用与各个物体向匹配的工具，如取出面包要用盘子、取出啤酒要用杯子、取出苹果要用篮子、取出现金要用钱包。迭代器的作用就相当于取出物品的工具的抽象，通过迭代器泛指现实生活中从贮藏室中取出物体的工具。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::iterator iter;这符语句定义了一个名为 iter 的变量，它的数据类型是 vector 定义的 iterator 类型。每个标准库容器类型都定义了一个名为 iterator 的成员，这里的 iterator 与迭代器实际类型的含义相同。begin 和 end 操作每种容器都定义了一对命名为 begin 和 end 的函数，用于返回迭代器。如果容器中有元素的话，由 begin 返回的迭代器指向第一个元素： vector::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 ivec(10,1);for(vector::iterator iter=ivec.begin();iter!=ivec.end();++iter){*iter=2; //使用 * 访问迭代器所指向的元素}b)const_iterator只能读取容器中的元素，而不能修改for(vector::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 操作返回的迭代器不指向任何元素，因此不能对它进行解引用或自增操作。

c++中迭代器是什么意思？C++中迭代器
C++中的容器
标准序列容器：vector、string、deque、list
标准关联容器：set、multiset、map、multimap
迭代器的分类
根据迭代器所支持的操作，可以把迭代器分为5类。
1、输入迭代器：是只读迭代器，在每个被遍历的位置上只能读取一次。
2、输出迭代器：是只写迭代器，在每个被遍历的位置上只能被写一次。
3、前向迭代器：兼具输入和输出迭代器的能力，但是它可以对同一个位置重复进行读和写。但它不支持operator--，所以只能向前移动。
4、双向迭代器：很像前向迭代器，只是它向后移动和向前移动同样容易。
5、随机访问迭代器：有双向迭代器的所有功能。而且，它还提供了“迭代器算术” ，即在一步内可以向前或向后跳跃任意位置。
C++容器中提供的迭代器
1、输入和输出迭代器的模型分别是建立在针对输入和输出流（例如文件）的读写操作基础上的。所以不难理解，输入和输出迭代器最常见的表现形式是　istream_iterator和ostream_iterator 。
2、所有的标准STL容器都支持比前向迭代器功能更强大的迭代器。（哈希容器的一种、单向链表容器例外，它们提供前向迭代器）
3、标准关联容器都提供了双向迭代器。list也是如此。
4、vector、string、deque都提供了随机访问迭代器。指向数组的内部指针对于数组来说也是随机访问迭代器。
istream_iterator和ostream_iterator使用示例
复制代码
// istream_iterator example
#include
#include
using namespace std;
int main () {
double value1, value2;
cout << "Please, insert two values: ";
istream_iterator eos;// end-of-stream iterator
istream_iterator iit (cin);// stdin iterator
if (iit!=eos) value1=*iit;
iit++;
if (iit!=eos) value2=*iit;
cout << value1 << "*" << value2 << "=" << (value1*value2) << endl;
return 0;
}
复制代码
output：
Please, insert two values: 2 32
2*32=64
复制代码
// ostream_iterator example
#include
#include
#include
using namespace std;
int main () {
vector myvector;
for (int i=1; i<10; ++i) myvector.push_back(i*10);
ostream_iterator out_it (cout,", ");
copy ( myvector.begin(), myvector.end(), out_it );
return 0;
}
复制代码
output：
10, 20, 30, 40, 50, 60, 70, 80, 90,

什么是迭代器?迭代器是一种对象，它能够用来遍历STL容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。迭代器修改了常规指针的接口，所谓迭代器是一种概念上的抽象：那些行为上象迭代器的东西都可以叫做迭代器。然而迭代器有很多不同的能力，它可以把抽象容器和通用算法有机的统一起来。
迭代器提供一些基本操作符：*、++、==、！=、= 。这些操作和C/C++“操作array元素”时的指针接口一致。不同之处在于，迭代器是个所谓的smart pointers，具有遍历复杂数据结构的能力。其下层运行机制取决于其所遍历的数据结构。因此，每一种容器型别都必须提供自己的迭代器。事实上每一种容器都将其迭代器以嵌套的方式定义于内部。因此各种迭代器的接口相同，型别却不同。这直接导出了泛型程序设计的概念：所有操作行为都使用相同接口，虽然它们的型别不同。
#include
using namespace std;
class _iterator
{
private:
char* p;
public:
_iterator(char* str):p(str){}
char*& operator++()
{
p+=1; //跟 p++同价;
return p;
}
};
int main()
{
char* p="This is C++ program";
_iterator it(p);
cout<<"++之前："<<p<<endl;
char* p1=++it; //把地址向前加了一个char 型长度,然后给指针p1
cout<<"++之后："<<p1<<endl;
return 0;
}

java,<E>什么意思？1、e.一般习惯用来做异常信息的输出处理2、比如在try ... catch块中，进行异常信息Exception e的对象e错误信息打印，如下：try {// 程序处理} catch(Exception e) {e.printStackTrace();}

Java Iterable和Iterator有什么区别和联系？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则不然，每次调用都返回一个从头开始的迭代器，各个迭代器之间互不影响。

请问java中的Iterator和Iterable有些什么区别?。?/h3>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则不然，每次调用都返回一个从头开始的迭代器，各个迭代器之间互不影响。

java一个有点难回答的问题，有关iterators的，Iterator a=b.iteratorb是一个集合实例，这个方法返回一个遍历集合元素的迭代器

Iterator<String> iter = lists.iterator();问什么不是new出来的?怎么记忆？对象都是new出来的，不过java的 Iterator类使用了工厂模式，对使用者隐藏了创建过程。你只需要记住每一个集合类型的对象都可以通过类似的对象.iterator()这样的方法取得相应的Iterator实例。

怎样检查一个iterator是否有内容>>> def isempty (ite):
>>> ... for _ in ite:
>>> ... ... return True
>>> ... return False

错误java.util.iterator无法转换为Iterator，第8行报错，为什么？你的程序有点小问题：类名不能是Iterator，与jdk自带的类名重名了 2. next()这样写3. 注释的话，应该用// ，而不是\\修改过的代码如下：import java.util.*;public class ShowDemo{ public static void main(String[] args){Collection c=new HashSet();c.add(new Name("f1","l1"));c.add(new Name("f2","l2"));c.add(new Name("f3","l3"));Iterator i = c.iterator();//报错while(i.hasNext()){Name n = (Name)i.next();System.out.print(n.getFirst()+" ");} } }class Name{ String first,last; Name(String first,String last){this.first = first;this.last = last; } public String getFirst(){return first; } public String getLast(){return last; }}

<s:iterator>有没有什么标识的就是像for循环一样的, 有个i, 能输出i的?这里的status是指迭代的状态,它底下的变量有index, count,odd..等等好几个,你的需求就用${#st.index}就可以了...如果你有多个迭代,你可以定义不同的status就行了..

s:iterator循环输出数字1.在action里加上maxNum属性，GET SET方法
2.第一种写法（推荐）

第二种写法，较第一种慢

3.struts2.0和2.1上在iterator这个标签上有区别
如果是2.1把id改成var就可以了

struts2 <s:iterator/>怎样取得循环的索引?#L.index，即为list的索引其中L是个IteratorStatus对象List<UserUser对象含有name和password属性。当然你也可以写成：<s:iterator value=https://www.zaoxu.com/jjsh/bkdq/list id=user status=L
struts 标签 <s:iterator>使用给你讲个例子吧，挺好明白的

这个例子的目的是：
把action中的List对象，在页面用把List的内容循环显示出来

首先有一个User对象
public class User {
private Integer userId；
private String userName；
private String userPwd；

//get和set方法
...........
}

action中的代码
List list = new ArrayList();

User user1 = new User();
user1.setUserId(1);
user1.setUserName("zhangsan");
user1.setUserPwd("123456");

list.add(user1);

User user2 = new User();
user2.setUserId(2);
user2.setUserName("lisi");
user2.setUserPwd("1234");

list.add(user2);
在把list放在request中，好在jsp页面中能拿到

jsp页面中的代码

//这个id加不加都没事

//这也可以写成

这样就可以了！希望对你能有所帮助。

struts2 <s:iterator><s:if></s:if></s:iterator> if怎么根据iterator的下标进行判断#status.count在struts2迭代标签里代表当前行数

下标小鱼等于2

2">

下标》2