Iterator迭代器模式（行为型模式）

集合内部与外部访问

左边是链表式的集合，右边是数组集合，迭代器实现的效果是不管集合是链表式还是数组形式，都可以在不暴露内部结构的同时，让外部客户代码透明地访问其中包含的元素。 

动机（Motivation）

在软件构建过程中，集合对象内部结构常常变化各异。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明地访问其中包含的元素；同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。

使用面向对象技术这种遍历机制抽象为“迭代器对象”应对“变化中的集合对象”提供一种优雅的方式。

意图（Intent）

提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

结构（Structure）

其中，

Aggregate：聚集抽象类

ConcreteAggregate：具体聚集类，继承Aggregate

Iterator：迭代抽象类，用于定义得到开始对象，得到下一个对象，判断是否到结尾，当前对象等抽象方法，统一接口

ConcreteIterator:具体迭代器类，继承Iterator，实现开始、下一个、是否结尾、当前对象等方法。

Iterator模式的几个要点

迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示

迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作

迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题

代码实现

实例背景：随着科技的进步，现在公交车直接支付宝扫码就可以了，在之前，公交车上都有一个售票员，负责检查上车成了买票。售票员不管上来的是人还是物（行李），不管是中国人还是外国人，不管是内部员工，还是小偷，只要是乘车的乘客，就必须要买票。把买票的对象看做一个聚集，里面包含了各个需要买票的对象，把售票员当做一个迭代器，需要遍历上车的乘客，遍历的方式有很多种，可以按照从前到后，从后到前，或者高矮胖瘦等，这可以看做具体的迭代器。

Iterator迭代器抽象类，/用于定义得到开始对象、得到下一个对象、判断是否到达结尾，当前对象等抽象方法，统一接口

    abstract class Iterator
    {
        public abstract object First();
        public abstract object Next();
        public abstract bool IsDone();
        public abstract object CurrentItem();
    }

 

 Aggregate聚集抽象类，里面有一个创建迭代器的抽象方法

    abstract class Aggregate
    {
        //创建迭代器
        public abstract Iterator CreateIterator();
    }

ConcreteIterator具体迭代器类，具体迭代器类，继承Iterator，实现开始、下一个、是否结尾、当前对象等方法。(售票员遍历上车的乘客)

class ConcreteIterator : Iterator
    {
        //定义了一个具体聚集对象
        private ConcreteAggregate aggregate;
        private int current = 0;
        //初始化时将具体的聚集对象传入
        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
        }
        //得到聚集的第一个对象
        public override object First()
        {
            return aggregate[0];
        }
        //得到聚集的下一个对象
        public override object Next() 
        {
            //...
        }
        //判断当前是否遍历到结尾，到结尾返回true
        public override bool IsDone()
        {
            return current >= aggregate.Count ? true : false;
        }
        //返回当前的聚集对象
        public override object CurrentItem()
        {
            return aggregate[current];
        }
    }

ConcreteAggregate具体聚集类，继承Aggregate（公交车聚合，里面存放各个乘客对象）

     class ConcreteAggregate : Aggregate
    {
        //声明一个IList泛型变量，用于存放聚合对象，用ArrayList同样可以实现
        private IList<object> items = new List<object>();
        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }
        //返回聚集总个数
        public int Count
        {
            get { return items.Count; }
        }
        //声明一个索引器
        public object this[int index]
        {
            get { return items[index]; }
            set { items.Insert(index, value); }
        }
    }

客户端代码

公交车，即聚集对象

  ConcreteAggregate a = new ConcreteAggregate();

上来的乘客，即对象数组

            a[0]="大鸟";
            a[1]="小菜";
            a[2] = "行李";
            a[3] = "老外";
            a[4] = "公交车内部人员";
            a[5] = "小偷";

售票员出场，即声明了迭代器的对象

Iterator i = new ConcreteIterator(a);

从第一个乘客开始，遍历告诉上车乘客买票

            object item = i.First();
            while (!i.IsDone())
            {
                Console.WriteLine("{0}请先买票！",i.CurrentItem());
                i.Next();
            }
            Console.Read();

结果显示

如果对上车乘客采取另外一种遍历方式的时候，可以再增加一个concreteaggregate具体迭代器，里面是遍历的方法就可以了。

适用场景

1.当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，就应该考虑使用迭代器模式。

2.当需要对聚集有多种方式遍历时，可以考虑用迭代器模式。

3.为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。