下面是ArrayList.java源代码的一部分：

1. public Iterator<E> iterator() {
   
2. return new Itr();
   
3. }
   
4. 
   
5. /**
   
6. * An optimized version of AbstractList.Itr
   
7. */
   
8. private class Itr implements Iterator<E> {
   
9. int cursor; // index of next element to return
   
10. int lastRet = -1; // index of last element returned; -1 if no such
    
11. int expectedModCount = modCount;
    
12. 
    
13. public boolean hasNext() {
    
14. return cursor != size;
    
15. }

复制代码

上面的
public Iterator<E> iterator()
{
        return new Itr();
    }
中Iterator不是接口类型吗，返回的不是对象吗，接口不是不能创建对象吗？

1. class CollectionDemo
   
2. {
   
3. public static void method_get()
   
4. {
   
5. ArrayList al = new ArrayList();
   
6. al.add("java01");
   
7. al.add("java02");
   
8. Iterator it = al.iterator();
   
9. }
   
10. }

复制代码

上面的Iterator it = al.iterator();中Iterator、it、al.iterator各是什么意思？

宋浩 发表于 2012-6-16 23:44
是的，建议看看多态吧，呵呵，那个看了之后对你编程帮助一定会挺大的！！ ...

恩，谢谢:D！

王红潮 发表于 2012-6-16 23:39
哦，也就是说，可以把它看成一个特殊的类，也可以创建一个指向子类对象的引用是吧！ ...

是的，建议看看多态吧，呵呵，那个看了之后对你编程帮助一定会挺大的！！

宋浩 发表于 2012-6-16 23:35
呵呵，接口，不过还不是可以算一种特殊的类！！重要的是理解上面的问题！！ ...

哦，也就是说，可以把它看成一个特殊的类，也可以创建一个指向子类对象的引用是吧！

王红潮 发表于 2012-6-16 23:22
这个Iterator不是类吧！

呵呵，接口，不过还不是可以算一种特殊的类！！重要的是理解上面的问题！！

import java.util.*;

class  t
{
        public static void main(String[] args)
        {
                 List list = new ArrayList();
  list.add("hello");
  list.add("java");
  Iterator it = list.iterator();//迭代器,一般在集合里面的东西，都用这个来读取数据。。。list.iterator 是调用对象的方法iterator（），
  while (it.hasNext()) {
   System.out.print(it.next());
  }


        }
}
///输出  hellojava

宋浩 发表于 2012-6-16 23:05
public Iterator iterator()
{
        return new Itr();

这个Iterator不是类吧！

jxj4227982333 发表于 2012-6-16 22:53
"上面的Iterator it = al.iterator();中Iterator、it、al.iterator各是什么意思？"
Iterator 是接口，it是 ...

是不是可以说，接口不可以创建对象，但可以创建一个接口类型的引用，用来指向接口的子类对象，以便于调用接口中的方法？

public Iterator<E> iterator()
{
        return new Itr();
}
中Iterator不是接口类型吗，返回的不是对象吗，接口不是不能创建对象吗？
它返回一个Iterator类型的对象没错，但是这个对象一定是实现了Iterator类的子类的对象，但并非Iterator实例化的对象，
return new Itr();这行代码不就很好的说明了吗？？但是为什么返回值要写一个Iterator呢？？这就涉及到多态了，如果
返回值写成Iterator，那么就可以返回任何一个实现了Iterator的子类的对象了，请问楼主这样是不是很方便呢？

上面的Iterator it = al.iterator();中Iterator、it、al.iterator各是什么意思？
Iterator表示的是Iterator类。。
it表示一个Iterator类的对象。。
a1.iterator()表示一个ArrayList对象调用它的iterator()方法。。

"上面的Iterator it = al.iterator();中Iterator、it、al.iterator各是什么意思？"
Iterator 是接口，it是接口类型的引用，不过它现在指向的是Iterator接口的子类对象。
就好比List是接口，不能创建对象，而ArrayList是它的子类，可以创建对象，于是就有
List list = new ArrayList();这叫做父类引用指向子类对象， 道理是一样的。
而iterator()是List集合的一种方法而已，调用它就可以获得这个集合的迭代器，也就是Iterator接口类型的子类。

Iterator 用在JSP页面 是 接收参数然后循环输出的
举个类的例子

hasNext()判断还有没有；next()选择下一个！

import java.util.*;
public class Test {

public static void main(String[] args){
  List l = Arrays.asList("one two three four five six seven".split(" "));
  Iterator it = l.iterator();
  while(it.hasNext())
   System.out.println(it.next());
  
}
}

输出

one
two
three
four
five
six
seven
他就是遍历模式的实现，因为java集合框架里有很多类，比如list都有好几种。而我们的程序又往往需要无视具体的实现类。简单来说就是比如要生成一个表格，表格数据可能是一个数组，也可能是个树状结构，你不可能为每个结构定一套代码，如果用iterator的话，只要传进来的参数是集合类，你就可以一路next并取值生成表格

上面的Iterator it = al.iterator();中Iterator、it、al.iterator各是什么意思？
Iterator 是 java 中的迭代器接口 ，用来遍历集合的，而 It 是申明的迭代器对象，
al.iterator 是调用对象al(ArrayList) 对象的方法iterator（），来生成　iterator 对象，
接口是不能实例化的，但是 接口对象可以引用子类的对象，
这就是 多态： 父类引用，指向子类对象：
建议楼主对研究一下 多态的概念！

Iterator代表接口  it表示接口类型的引用，即其子类对象名，al.iterator(),ArrayList中的方法被其对象调用，方法的功能是返回一个Iterator接口类型的子类
对象，并由其子类对象调用其中实现Iterator接口的方法（hasNext(),next(),remove()方法），即内部类Itr实现了外部类或接口并私有化，并通过对外的方法访问，保证了程序的封装和多态。下面是源代码，看一下
interface Iterator     
{
   public abstract boolean hasNext();
   public abstract E next();
   public abstract void remove();
   public abstract void checkForComodification();
}
public Iterator<E> iterator() {
        return new Itr();
    }

private class Itr implements Iterator<E> {
        int cursor = 0;
        int lastRet = -1;
        int expectedModCount = modCount;
        public boolean hasNext() {
            return cursor != size();
        }
        public E next() {
            checkForComodification();
            try {
                int i = cursor;
                E next = get(i);
                lastRet = i;
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }
        public void remove() {
            if (lastRet < 0)
                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();
        }
    }