转自：http://blog.csdn.net/acmman/article/details/43920153
在遍历容器元素的时候，有很多初学者在疑惑，为什么返回一个iterator我就能够去遍历这个容器了呢？
今天我们就来深入剖析一下迭代器iterator的设计模式(循序渐进的剖析，一定要耐心看完)
iterator是"四人帮"所定义的23种设计模式之一(不太难，也不是非常重要，只是在遍历容器的时候能够用到)
首先需要读这个总结的同志掌握面向对象的思想。
1.我们先自己写一个可以动态添加对象的容器
建立一个新的Java工程：Iterator
创建一个包：cn.edu.hpu.iterator
在包下创建类ArrayList：
我们要在容器内首先添加一个add方法，用于向容器内添加元素
再写一个size方法，用于查找容器元素个数
ArrayList.java:
测试:
测试结果:20我们就完成了这样一个容器，这个容器是用数组来实现的。容器比数组好在哪里呢？使用容器就不需要考虑到数组的边界问题了，容器可以动态拓展。想往里面装就add就行了，想知道大小直接size就可以了。
2.我们加一个辅助类Cat
Cat.java:
以后添加元素就添加这个就可以了，因为可以通过id值知道添加了哪些数据
如测试:
3.OK，现在我腻歪了，不想用ArrayList容器了，我想用其它容器去装Cat，这个新的容器我们底层不用数组实现了，我们用链表来实现。（需要你先了解数据结构中的链表概念）
建立一个新容器类LinkedList,一个节点类Node
LinkedList.java:
Node.java:
测试:
测试结果:20
我们实现了两个内部原理完全不同的容器，那么下面我们来看:
4.考虑容器的可替换性
什么叫做可替换性？考虑我们使用容器的客户端类，想使这些容器可以任意的替换，其它代码不用改变，这就需要我们把所有容器的对外提供的方法统一起来。
解决方案:
我们写一个统一的接口Collection，定义一些统一的规范，让所有容器去实现这个接口。
Collection.java:
ArrayList.java:
LinkedList.java:
这样我们就用Collection接口来实现对不同容器对外方法的统一。
在我们测试的时候就可以使用这种方式来实现容器:
Collection c=new ArrayList();
我对ArrayList不满意，就可以改成
Collection c=new LinkedList();
小结：针对接口编程就不需要考虑具体的实现类是什么，所以你的程序会更加灵活，要替换其它实现的时候，只需换一个位置(当然如果你写在配置文件上，你连代码都不用改)。
5.接下来重点来了，我们的容器需要一个非常非常重要的功能-------遍历
我想遍历容器中的所有元素，如何去做？
当然可以这样来写:
结果:
20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
但是，当我们将Collection的实现改为LinkedList的时候下面的遍历方法就不行了。
这个时候就需要一种统一的遍历方式。
每一种容器都应该有它自己的一种遍历方式，我们要想方设法的给他们统一起来，但是每种容器的遍历器的实现又不一样，所以统一遍历方式只能用一种共同的实现方式，接口或抽象类的方式。
所以我们这么写：
定义一个接口Iterator：
其中有两个未实现的方法:next和hasNext。
我要求任何一个容器都必须给我一个实现了这个接口的类的对象，
具体的实现交给具体的容器自己去实现。实现完了之后，我肯定知道，
这个对象就实现这两个方法了，有了这两个方法，我就可以实现对这
个容器的遍历了。
我们在Collection中加入返回Iterator的未实现方法
ArrayList实现了iterator()这个方法
测试:
这样我们怎么改变Collection的实现类，都不影响遍历方式。
6.当然我没还没有写Iterator的实现，我们来写实现：
我们在ArrayList中写一个内部类ArrayListIterator，实现Iterator接口：
测试:
测试结果:
20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
在我们的JavaAPI中的ArrayList也实现了Java的Collection接口，同样提供了一个方法，
叫iterator()，这个方法返回了一个实现了Iterator接口的对象。
现在大家明白iterator()方法到底是干什么用的，它返回的接口又是什么意思了吧？
作业:
这个LinkedList也需要写一个iterator方法，返回一个实现了Iterator的对象。该如何写？
这是我自己写的: http://blog.csdn.net/acmman/article/details/43924261
感谢马士兵老师的"设计模式"视频提供的帮助
转载请注明出处:http://blog.csdn.net/acmman/article/details/43920153
转自：http://www.cnblogs.com/ysw-go/p/5384516.html
迭代器模式定义
迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。
迭代器模式的角色构成
(1)迭代器角色（Iterator）:定义遍历元素所需要的方法，一般来说会有这么三个方法：取得下一个元素的方法next()，判断是否遍历结束的方法hasNext()），移出当前对象的方法remove(),
(2)具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代。
(3)容器角色(Aggregate): 一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等
(4)具体容器角色（ConcreteAggregate）：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。
迭代器模式应用的场景及意义
(1)访问一个聚合对象的内容而无需暴露它的内部表示
(2)支持对聚合对象的多种遍历
1 public interface Iterator { 2 3 public boolean hasNext(); 4 public Object next(); 5 }
定义具体迭代器角色(Concrete Iterator)
1 package patten.design; 2 3 import patten.design.List;; 4 5 public class ConcreteIterator implements Iterator { 6 private List list = null; 7 private int index; 8 9 public ConcreteIterator(List list) { 10 super(); 11 this.list = list; 12 } 13 14 @Override 15 public boolean hasNext() { 16 if (index >= list.getSize()) { 17 return false; 18 } else { 19 return true; 20 } 21 } 22 23 @Override 24 public Object next() { 25 Object object = list.get(index); 26 index++; 27 return object; 28 } 29 30 }
定义容器角色(Aggregate)
1 package patten.design; 2 3 //定义集合可以进行的操作 4 public interface List { 5 6 public void add(Object obj); 7 public Object get(int index); 8 public Iterator iterator(); 9 public int getSize(); 10 }
定义具体容器角色(ConcreteAggregate)
1 package patten.design; 2 3 public class ConcreteAggregate implements List{ 4 5 private Object[] list; 6 private int size=0; 7 private int index=0; 8 public ConcreteAggregate(){ 9 index=0; 10 size=0; 11 list=new Object[100]; 12 } 13 @Override 14 public void add(Object obj) { 15 list[index++]=obj; 16 size++; 17 } 18 19 @Override 20 public Iterator iterator() { 21 22 return new ConcreteIterator(this); 23 } 24 @Override 25 public Object get(int index) { 26 27 return list[index]; 28 } 29 @Override 30 public int getSize() { 31 32 return size; 33 } 34 35 }
代码测试
1 package patten.design; 2 3 public class IteratorTest { 4 5 /** 6 * @param args 7 */ 8 public static void main(String[] args) { 9 10 List list=new ConcreteAggregate(); 11 list.add("a"); 12 list.add("b"); 13 list.add("c"); 14 list.add("d"); 15 Iterator it=list.iterator(); 16 while(it.hasNext()){ 17 System.out.println(it.next()); 18 } 19 } 20 21 }
迭代器模式的优缺点：
迭代器模式的优点有：
- 简化了遍历方式，对于对象集合的遍历，还是比较麻烦的，对于数组或者有序列表，我们尚可以通过游标来取得，但用户需要在对集合了解很清楚的前提下，自行遍历对象，但是对于hash表来说，用户遍历起来就比较麻烦了。而引入了迭代器方法后，用户用起来就简单的多了。
- 可以提供多种遍历方式，比如说对有序列表，我们可以根据需要提供正序遍历，倒序遍历两种迭代器，用户用起来只需要得到我们实现好的迭代器，就可以方便的对集合进行遍历了。
- 封装性良好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心。
迭代器模式的缺点：
- 对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐，大家可能都有感觉，像ArrayList，我们宁可愿意使用for循环和get方法来遍历集合。
总的来说： 迭代器模式是与集合共生共死的，一般来说，我们只要实现一个集合，就需要同时提供这个集合的迭代器，就像java中的Collection，List、Set、Map等，这些集合都有自己的迭代器。假如我们要实现一个这样的新的容器，当然也需要引入迭代器模式，给我们的容器实现一个迭代器。
738
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
