解读设计模式----迭代器模式(Iterator Pattern)

1、你在开发中使用过迭代吗？
     当你在使用JavaScript开发客户端应用的时候使用过for...in吗?
 

 1 < script type = " text/javascript " >
 2 var  obj;
 3 useForIn  =   function  ()
 4 {
 5   obj = (0,1,2,3,4,5,6,7,8,9);
 6   for(var o in obj)
 7   {
 8      document.write(o);
 9   }
10}
11 < / script>

 

      当你在.NET Frameworks上使用C#,VB.NET,等语言开发应用的时候使用过foreach....in吗?
 

 1 class  Program
 2 {
 3    static void Main(string[] args)
 4    {
 5        List<int> list = new List<int>();
 6        //--------初始化集合-----------
 7        for (int i = 0; i < 10; i++)
 8        {
 9            list.Add(i);
10        }
11        //-------遍历集合--------------
12        foreach (int i in list)
13        {
14            Console.WriteLine(i);
15        }
16    }
17}

     若是你是一位Java发烧者,你在遍历集合的时候是使用什么方式呢?是 Iterator?仍是for?
 

 1 import  java.util. * ;
 2 public   class  UseForIn  {
 3    public static void main(String[] args) {
 4        List<String> list = new ArrayList<String>();
 5        for (int i = 0; i < 10; i++) {
 6            list.add("String:" + i);
 7        }
 8        //--------------使用Iterator遍历集合---------------
 9        Iterator it = list.iterator();
10        while(it.hasNext()){
11            System.out.println(it.next());
12        }
13        //------使用for.in(JDK 1.5以更高版本才能支持)-----
14        
15        for (String s : list ){
16            System.out.println(s);
17        }
18    }
19}

 

2、解说迭代模式
     咱们先来看看迭代器模式的UML图(下图来至 [url]http://www.dofactory.com/[/url])
        

迭代器模式（Iterator）

迭代器模式（Iterator）,提供一种方法顺序访问一个集合对象中的各个元素，而不暴露该对象的内部表示。

        能够说，.NET Frameworks中的每个集合对象，都应用了Iterator模式。一个汇集对象，并且无论这些对象是何时都须要遍历的时候，咱们都应该使用迭代器模式。另外在咱们须要为集合对象提供多种遍历方式的时候也能够考虑用迭代器模式。

        原本这个模式仍是颇有意思的，不过现今来看迭代器模式实用价格远不如学习价值大了。由于如今的高级编程语言如C#,Java等自己已经把这个模式作在语言中了。回到本文开始，我想你就可以明白我为何在文章的开始部分就发起提问？就拿C#的foreach....in语言来讲吧，他就是一个能够遍历全部的集合对象的工具，并且很是好用。

        另外还有像IEnumerable接口也是为迭代器模式而准备的，无论如何，学习一下GOF的迭代器模式的基本结构，仍是颇有学习价值的。研究历史是为了更好地迎接将来（这句话是Copy一本设计模式的书上，我一下忘了，若有知道的能够在下面留言告诉下）。

3、悟透foreach....in语句
        为了使用户更方便的遍历集合对象的全部元素，C#提供了foreach...in语句，该语句的实现正是经过IEnumerable的MoveNext()来完成遍历的。
        为了验证foreach....in语句与迭代器的关系，咱们来定义一个实现逆序遍历集合的类ReverseList类，定义很简单，只须要继承ArrayList类，并重写GetEnumerator方法既可。
 

 1 namespace  DesignPattern.Iterator
 2 {
 3    public class ReverseList:ArrayList
 4    {
 5        public override IEnumerator GetEnumerator()
 6        {
 7            return new ReverseListEnumerator(this);
 8        }
 9    }
10}

    其中，类ReverseListEnumerator实现了IEnumerator，它提供了逆序遍历的迭代器。定义以下：
 

 1 using  System;
 2 using  System.Collections.Generic;
 3 using  System.Text;
 4 using  System.Collections;
 5
 6 namespace  DesignPattern.Iterator
 7 {
 8    public class ReverseListEnumerator:IEnumerator
 9    {
10        public ReverseListEnumerator(ArrayList list)
11        {
12            this.list = list;
13            this.index = list.Count;
14            this.CurrentElement = list;
15        }
16
17        private object CurrentElement;
18        private int index;
19        private ArrayList list;
20
21        public object Current
22        {
23            get 
24            {
25                object obj = this.CurrentElement;
26                if (obj != this.list)
27                {
28                    return obj;
29                }
30                if (this.index == -1)
31                {
32                    throw new Exception("索引超出下标范围！");
33                }
34            }
35        }
36
37        public bool MoveNext()
38        {
39            if (this.index > 0)
40            {
41                this.index--;
42                this.CurrentElement = this.list[this.index];
43                return true;
44            }
45            this.CurrentElement = this.list;
46            this.index = 0;
47            return false;
48        }
49
50        public void Reset()
51        {
52            this.CurrentElement = this.list;
53            this.index = this.list.Count;
54        }
55    }
56}
57

     咱们来比较下使用ArrayList和自定义的ReverseList类经过foreach....in遍历后的结果：
 

 1 using  System;
 2 using  System.Collections.Generic;
 3 using  System.Text;
 4
 5 namespace  DesignPattern.Iterator
 6 {
 7    class Program
 8    {
 9        static void Main(string[] args)
10        {
11            List<int> list = new List<int>();
12            ReverseList rlist = new ReverseList();
13            //--------初始化数据-----------------------
14            for (int i = 0; i < 10; i++)
15            {
16                list.Add(i);
17                rlist.Add(i);
18            }
19            //-----使用C#的foreach.in语句(顺序遍历类ArrayList)-------
20            foreach (int i in list)
21            {
22                Console.Write(i + " ");
23            }
24            Console.WriteLine();  //起换行做用
25
26            //--------使用自定义的逆序遍历类（ReverseList）--------------
27            foreach (int i in rlist)
28            {
29                Console.Write(i + " ");
30            }
31            Console.WriteLine();  //起换行做用
32        }
33    }
34}

 

运行结果以下：

 

4、现实生活中的迭代高手
     我想对于大多数（有一部分人本身有车，有部分人骑自行车或摩托车，有部分人步行）的人来讲，天天都有这样的经历，早晨起床后一阵忙碌，忙完了就是准备上班了。来到了公交车站，XX分钟过去后，到上班点的公交来了，这时该作什么？上贝，不上你就等着上班迟到吧，哈哈。
     仔细观察售票员就会发现，每到一个站点，公交车都会停下上客或是下客，人多混杂(有的是买过票的，有的还没买过)，我真佩服售票员的记忆，乘客随时都在上下，他老是能记住上了那些人，其中那些又是没有买票的。他能够从车头卖票到车尾，也能够从车尾到车头，也能够就在车门那站着售票，呵呵，这好象也迭代器有很大的联系。看看下面代码：
 

1 public   class  公交车:ArrayList
2 {
3    
4}

     直接继承ArrayList，什么也不作，这时[公交车]也就拥有了ArrayList的公开属性和方法。下面是[乘客类]；
 

 1 using  System;
 2 using  System.Collections.Generic;
 3 using  System.Text;
 4
 5 namespace  DesignPattern.Iterator
 6 {
 7    public class 乘客
 8    {
 9        public 乘客() { }
10        public 乘客(string name, bool flag)
11        {
12            this.name = name;
13            this.flag = flag;
14        }
15
16        private string name;
17        public string Name
18        {
19            get { return name; }
20            set { name = value; }
21        }
22
23        private bool flag;
24        public bool Flag
25        {
26            get { return flag; }
27            set { flag = value; }
28        }
29    }
30}

    乘客名字和标识（是否买过票），看看下面的示例；
 

 1 namespace  DesignPattern.Iterator
 2 {
 3    class Program
 4    {
 5        static void Main(string[] args)
 6        {
 7            公交车 gjc = new 公交车();
 8            乘客 ck = null;
 9            //乘客上车
10            for (int i = 0; i < 5; i++)
11            {
12                ck = new 乘客(i + 1 + "号乘客", false);
13                gjc.Add(ck);
14            }
15            //迭代高手出场--收车费--所有收完
16            for (int i = 0; i < gjc.Count; i++)
17            {
18                乘客 c = (乘客)gjc[i];
19                c.Flag = true;
20            }
21            //到了一站--张三和李四上了车
22            //售票员还没来收张三的钱呢，不会是在考验张三是否是自觉掏钱买票吧
23            gjc.Add(new 乘客("张三", false));
24            gjc.Add(new 乘客("李四", true)); //这人老实，一上车就自动购票
25
26            foreach (乘客 k in gjc)
27            {
28                if (k.Flag)
29                {
30                    Console.WriteLine("到终点站了,{0}请下车！", k.Name);
31                }
32                if (!k.Flag)
33                {
34                    Console.WriteLine("你好{0}同志,你尚未买票,要走能够,请先买票！", k.Name);
35                }
36            }
37        }
38    }
39}

     上面的代码很简单，我就不作详细解说，运行结果以下图：
      

5、总结迭代高手
        从上面的几个示例中就能够看出，尽管咱们没有显示的引用迭代器，但实质仍是经过迭代器来遍历的。总地来讲， 迭代器模式就是分离了集合对象的迭代行为，抽象出一个迭代器类来负责，这样既可作到不暴露集合的内部结构，又可让外部代码能够透明的访问集合内部的元素。         迭代器模式在访问数组、集合、列表等数据时，尤为是数据库数据操做时，是很是广泛的应用，但因为它太广泛了，因此各类高级语言都对他进行了封装，因此反而给人感受此模式自己不太经常使用了。         看来现实生活中的售票员就是一位了不得的迭代高手，每次乘客上下车他都会数数进行统计，而后根据他本身的迭代方式去遍历车内的乘客进行售票，不会放过任何逃票之客。         任何行业都有技巧和经验，须要多思考、多琢磨，才能作到最好的。         编程又未尝不是这样，没有最好，只有更好，咱们都须要努力。 注：上面总结源于《大话设计模式》