Java设计模式——Iterator迭代器转自：http://blog.csdn.net/acmman/article/details/43920153转自：http://www.cnblogs.com/ysw-go/p/5384516.html

65 阅读 0 评论 43 点赞

我是靠谱客的博主感性冷风，最近开发中收集的这篇文章主要介绍Java设计模式——Iterator迭代器转自：http://blog.csdn.net/acmman/article/details/43920153转自：http://www.cnblogs.com/ysw-go/p/5384516.html，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

转自：http://blog.csdn.net/acmman/article/details/43920153

在遍历容器元素的时候，有很多初学者在疑惑，为什么返回一个iterator我就能够去遍历这个容器了呢？

今天我们就来深入剖析一下迭代器iterator的设计模式(循序渐进的剖析，一定要耐心看完)

iterator是"四人帮"所定义的23种设计模式之一(不太难，也不是非常重要，只是在遍历容器的时候能够用到)

首先需要读这个总结的同志掌握面向对象的思想。

1.我们先自己写一个可以动态添加对象的容器
建立一个新的Java工程：Iterator
创建一个包：cn.edu.hpu.iterator
在包下创建类ArrayList：
我们要在容器内首先添加一个add方法，用于向容器内添加元素
再写一个size方法，用于查找容器元素个数

ArrayList.java:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public class ArrayList {  
     //我们要用数组模拟一个可以添加任意大小元素的容器  
     //首先我们固定一个数组空间，再添加元素的时候，我们去判断  
     //这个空间是不是满了，如果满了再在此基础上再添加一个固定空间  
     //往下依次类推，这样就有了可以添加任意大小元素的容器  
     //当然，容器大小一定不可能超过计算机内存的大小  
     Object[] objects=new Object[10];   
     int index=0;//代表objects的下一个空的位置在哪里  
       
     //添加元素方法  
     public void add(Object o){  
         if(index==objects.length){  
             //原来的数组已满，要做扩展(原长度X2)  
             Object[] newObjects=new Object[objects.length*2];  
             //把objects内容拷贝到新的数组newObjects上  
             System.arraycopy(objects, 0, newObjects, 0, objects.length);//数组拷贝函数  
             objects=newObjects;//之后把newObjects拷贝给objects数组  
         }  
         objects[index]=o;  
         index++;  
     }  
       
     //获取容器元素个数方法  
     public int size(){  
         return index;  
     }  
 }  

测试:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 import cn.edu.hpu.iterator.ArrayList;  
   
 public class ArrayListTest {  
     public static void main(String[] args) {  
         ArrayList al=new ArrayList();  
         for(int i=0;i<20;i++){  
             al.add(new Object());  
         }  
         System.out.println(al.size());  
     }  
 }  

测试结果:20

我们就完成了这样一个容器，这个容器是用数组来实现的。容器比数组好在哪里呢？使用容器就不需要考虑到数组的边界问题了，容器可以动态拓展。想往里面装就add就行了，想知道大小直接size就可以了。

2.我们加一个辅助类Cat
Cat.java:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public class Cat {  
     private int id;  
   
   
     public Cat(int id) {  
         super();  
         this.id = id;  
     }  
       
     public int getId() {  
         return id;  
     }  
       
     public void setId(int id) {  
         this.id = id;  
     }  
 }  

以后添加元素就添加这个就可以了，因为可以通过id值知道添加了哪些数据
如测试:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 import cn.edu.hpu.iterator.ArrayList;  
   
 public class ArrayListTest {  
     public static void main(String[] args) {  
         ArrayList al=new ArrayList();  
         for(int i=0;i<20;i++){  
             al.add(new Cat(i));  
         }  
         System.out.println(al.size());  
     }  
 }  

3.OK，现在我腻歪了，不想用ArrayList容器了，我想用其它容器去装Cat，这个新的容器我们底层不用数组实现了，我们用链表来实现。（需要你先了解数据结构中的链表概念）
建立一个新容器类LinkedList,一个节点类Node
LinkedList.java:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public class LinkedList {  
     Node head=null;//头节点(以后的元素通过next得到)  
     Node tail=null;//尾节点  
     int size=0;  
     public void add(Object o){  
         Node n=new Node(o,null);  
         if(head==null){  
             head=n;  
             tail=n;  
         }  
         tail.setNext(n);  
         tail=n;  
         size++;  
           
     }  
       
     public int size(){  
         return size;  
     }  
 }  

Node.java:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public class Node {  
     private Object data;  
     private Node next;  
       
       
     public Node(Object data, Node next) {  
         super();  
         this.data = data;  
         this.next = next;  
     }  
       
     public Object getData() {  
         return data;  
     }  
       
     public void setData(Object data) {  
         this.data = data;  
     }  
       
     public Node getNext() {  
         return next;  
     }  
       
     public void setNext(Node next) {  
         this.next = next;  
     }  
       
 }  

测试:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 import cn.edu.hpu.iterator.LinkedList;  
   
 public class LinkedListTest {  
     public static void main(String[] args) {  
         LinkedList ll=new LinkedList();  
         for(int i=0;i<20;i++){  
             ll.add(new Cat(i));  
         }  
         System.out.println(ll.size());  
     }  
 }  

测试结果:20

我们实现了两个内部原理完全不同的容器，那么下面我们来看:

4.考虑容器的可替换性
什么叫做可替换性？考虑我们使用容器的客户端类，想使这些容器可以任意的替换，其它代码不用改变，这就需要我们把所有容器的对外提供的方法统一起来。
解决方案:
我们写一个统一的接口Collection，定义一些统一的规范，让所有容器去实现这个接口。
Collection.java:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public interface Collection {  
     void add(Object o);  
     int size();  
 }  

ArrayList.java:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public class ArrayList implements Collection{  
       
     Object[] objects=new Object[10];   
     int index=0;  
     public void add(Object o){  
         if(index==objects.length){  
               
             Object[] newObjects=new Object[objects.length*2];  
               
             System.arraycopy(objects, 0, newObjects, 0, objects.length);  
             objects=newObjects;  
         }  
         objects[index]=o;  
         index++;  
     }  
       
     public int size(){  
         return index;  
     }  
 }  

LinkedList.java:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public class LinkedList implements Collection{  
     Node head=null;  
     Node tail=null;  
     int size=0;  
     public void add(Object o){  
         Node n=new Node(o,null);  
         if(head==null){  
             head=n;  
             tail=n;  
         }  
         tail.setNext(n);  
         tail=n;  
         size++;  
           
     }  
       
     public int size(){  
         return size;  
     }  
 }  

这样我们就用Collection接口来实现对不同容器对外方法的统一。
在我们测试的时候就可以使用这种方式来实现容器:
Collection c=new ArrayList();
我对ArrayList不满意，就可以改成
Collection c=new LinkedList();

小结：针对接口编程就不需要考虑具体的实现类是什么，所以你的程序会更加灵活，要替换其它实现的时候，只需换一个位置(当然如果你写在配置文件上，你连代码都不用改)。

5.接下来重点来了，我们的容器需要一个非常非常重要的功能-------遍历
我想遍历容器中的所有元素，如何去做？
当然可以这样来写:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 import cn.edu.hpu.iterator.ArrayList;  
 import cn.edu.hpu.iterator.Collection;  
   
 public class ArrayListTest {  
     public static void main(String[] args) {  
         Collection c=new ArrayList();  
         for(int i=0;i<20;i++){  
             c.add(new Cat(i));  
         }  
         System.out.println(c.size());  
           
         ArrayList al=(ArrayList)c;  
         for(int i=0;i<al.index;i++){  
             Cat cat=(Cat)al.objects[i];  
             System.out.print(cat.getId()+" ");  
         }  
     }  
 }  

结果:
20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

但是，当我们将Collection的实现改为LinkedList的时候下面的遍历方法就不行了。
这个时候就需要一种统一的遍历方式。

每一种容器都应该有它自己的一种遍历方式，我们要想方设法的给他们统一起来，但是每种容器的遍历器的实现又不一样，所以统一遍历方式只能用一种共同的实现方式，接口或抽象类的方式。

所以我们这么写：
定义一个接口Iterator：

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public interface Iterator {  
     Object next();  
     boolean hasNext();  
 }  

其中有两个未实现的方法:next和hasNext。
我要求任何一个容器都必须给我一个实现了这个接口的类的对象，
具体的实现交给具体的容器自己去实现。实现完了之后，我肯定知道，
这个对象就实现这两个方法了，有了这两个方法，我就可以实现对这
个容器的遍历了。

我们在Collection中加入返回Iterator的未实现方法

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public interface Collection {  
     void add(Object o);  
     int size();  
     Iterator iterator();  
 }  

ArrayList实现了iterator()这个方法

[java]  
   view plain 
    copy 
    
   
 public Iterator iterator(){  
         return null;  
     }  

测试:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 import cn.edu.hpu.iterator.ArrayList;  
 import cn.edu.hpu.iterator.Collection;  
 import cn.edu.hpu.iterator.Iterator;  
   
 public class ArrayListTest {  
     public static void main(String[] args) {  
         Collection c=new ArrayList();  
         for(int i=0;i<20;i++){  
             c.add(new Cat(i));  
         }  
         System.out.println(c.size());  
           
         /*之前的方法 
                 ArrayList al=(ArrayList)c; 
         for(int i=0;i<al.index;i++){ 
             Cat cat=(Cat)al.objects[i]; 
             System.out.print(cat.getId()+" "); 
         }*/  
   
                 //使用统一遍历器的遍历方法  
                 ArrayList al=(ArrayList)c;  
         Iterator it=c.iterator();  
         while(it.hasNext()){  
             Object o=it.next();  
             Cat cat=(Cat)o;  
             System.out.print(cat.getId()+" ");  
         }  
     }  
 }  

这样我们怎么改变Collection的实现类，都不影响遍历方式。

6.当然我没还没有写Iterator的实现，我们来写实现：
我们在ArrayList中写一个内部类ArrayListIterator，实现Iterator接口：

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 public class ArrayList implements Collection{  
   
     Object[] objects=new Object[10];   
     int index=0;  
       
     public void add(Object o){  
         if(index==objects.length){  
               
             Object[] newObjects=new Object[objects.length*2];  
       
             System.arraycopy(objects, 0, newObjects, 0, objects.length);  
             objects=newObjects;  
         }  
         objects[index]=o;  
         index++;  
     }  
       
     public int size(){  
         return index;  
     }  
       
     public Iterator iterator(){  
         return new ArrayListIterator();  
     }  
       
     private class ArrayListIterator implements Iterator{  
   
   
         private int currentIndex=0;  
           
         @Override  
         public boolean hasNext() {  
             if(currentIndex>index) return false;  
             else return true;  
         }  
   
         @Override  
         public Object next() {  
             Object o=objects[currentIndex];  
             currentIndex++;  
             return o;  
         }  
           
     }  
 }  

测试:

[java]  
   view plain 
    copy 
    
   
 package cn.edu.hpu.iterator;  
   
 import cn.edu.hpu.iterator.ArrayList;  
 import cn.edu.hpu.iterator.Collection;  
 import cn.edu.hpu.iterator.Iterator;  
   
   
 public class ArrayListTest {  
     public static void main(String[] args) {  
         Collection c=new ArrayList();  
         for(int i=0;i<20;i++){  
             c.add(new Cat(i));  
         }  
         System.out.println(c.size());  
   
   
                 //使用统一遍历器的遍历方法  
         ArrayList al=(ArrayList)c;  
         Iterator it=c.iterator();  
         while(it.hasNext()){  
             Object o=it.next();  
             Cat cat=(Cat)o;  
             System.out.print(cat.getId()+" ");  
         }  
     }  
 }  

测试结果:
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)支持对聚合对象的多种遍历

(3)为遍历不同的聚合结构提供一个统一的接口

迭代器模式四个角色之间的关系可以用类图表示

具体代码实现：

定义迭代器角色(Iterator)

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表来说，用户遍历起来就比较麻烦了。而引入了迭代器方法后，用户用起来就简单的多了。
可以提供多种遍历方式，比如说对有序列表，我们可以根据需要提供正序遍历，倒序遍历两种迭代器，用户用起来只需要得到我们实现好的迭代器，就可以方便的对集合进行遍历了。
封装性良好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心。

迭代器模式的缺点：