迭代器为啥不是new出来的呢？

这是因为创建对象的逻辑被iterator()方法封装了

因为是创建集合后，调用iterator方法后返回的Iterator类型的对象才具备hasNext方法、next方法等，而这些方法所在的类是被封装在集合内部的，所以去除方式就可以直接访问集合内部元素。

额，因为那些集合实现了Iterator接口，由于数据结构不同，遍历的方式也不同，所以需要集合自定义变量方法，但是为了统一所以实现相同接口，以便于规范。

好高深的回答

我的理解是：其实它就是对象，只不过是被封装在iterator()方法中

被封装了！

具有迭代功能的集合是因为实现了Iterable接口， Iterable接口中只定义的一个返回值为Interator类型的iterator()方法，   实现Iterable接口的集合中覆写了iterator(),返回一个符合该集合数据结构的Iterator对象。

我也没看懂！！

以ArrayList为例，看一下它的源代码：

1. package java.util;
   
2. 
   
3. public class ArrayList<E> extends AbstractList<E>
   
4.                                       implements List<E>, RandomAccess, Cloneable, java.io.Serializable
   
5. {
   
6. 
   
7.         //这是从Collection接口继承得到的iterator方法
   
8.         public Iterator<E> iterator() {
   
9.                //下面的代码返回了一个Itr类的实例
   
10.         return new Itr();
    
11.     }
    
12. 
    
13.     //私有内部类Itr，实现了Iterable接口
    
14.     private class Itr implements Iterator<E> {
    
15.         int cursor;       // index of next element to return
    
16.         int lastRet = -1; // index of last element returned; -1 if no such
    
17.         int expectedModCount = modCount;
    
18. 
    
19.         public boolean hasNext() {
    
20.             return cursor != size;
    
21.         }
    
22. 
    
23.         @SuppressWarnings("unchecked")
    
24.         public E next() {
    
25.             checkForComodification();
    
26.             int i = cursor;
    
27.             if (i >= size)
    
28.                 throw new NoSuchElementException();
    
29.             Object[] elementData = ArrayList.this.elementData;
    
30.             if (i >= elementData.length)
    
31.                 throw new ConcurrentModificationException();
    
32.             cursor = i + 1;
    
33.             return (E) elementData[lastRet = i];
    
34.         }
    
35. 
    
36.         public void remove() {
    
37.             if (lastRet < 0)
    
38.                 throw new IllegalStateException();
    
39.             checkForComodification();
    
40. 
    
41.             try {
    
42.                 ArrayList.this.remove(lastRet);
    
43.                 cursor = lastRet;
    
44.                 lastRet = -1;
    
45.                 expectedModCount = modCount;
    
46.             } catch (IndexOutOfBoundsException ex) {
    
47.                 throw new ConcurrentModificationException();
    
48.             }
    
49.         }
    
50. 
    
51.         final void checkForComodification() {
    
52.             if (modCount != expectedModCount)
    
53.                 throw new ConcurrentModificationException();
    
54.         }
    
55.     }
    
56. }

复制代码

从上面代码可以看出，ArrayList的iterator方法返回的是一个内部类Itr的实例，该内部类实现了Iterator接口。

不仅仅是ArrayList，你可以从其他的集合类中找到类似的代码。

iterator的构造函数被私有化了，但调用iterator（）函数可以返回一个Iterator类型的对象。这是单例设计的思想。

迭代器接口出现：将每一个容器中的取出方式进行了封装。并对外暴露。
这样无论是什么容器或者数据结构，只要内部取出方式实现了Iterator接口
都可以通过该接口取出这些容器中的元素
它的出现，将容器的取出方式和容器的数据结构相分离，降低了耦合性
而取出方式因为直接在访问容器中的元素，并依赖具体的数据结构，所以被定义在了容器中
通过内部类来实现Itertor接口