迭代器模式

介绍

迭代器模式（Interator）：又称游标模式。提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示

聚合对象的职责：1.存储数据，聚合对象的基本职责。2.遍历数据，既是可变化的，又是可分离的

结构图

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

其实在高级编程语言如C#、JAVA等本身已经把这个模式做在语言当中了，例如C#中的foreach in

例子

代码实现

Aggregate聚集抽象类

abstract class Aggregate
    {
        public abstract Iterator CreateIterator();
    }

ConcreteInterator具体的迭代器类，继承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()
        {
            object ret = null;
            current++;

            if (current < aggregate.Count)
            {
                ret = aggregate[current];
            }

            return ret;
        }

        public override object CurrentItem()
        {
            return aggregate[current];
        }

        public override bool IsDone()
        {
            return current >= aggregate.Count ? true : false;
        }

    }

ConcreteAggregate 具体聚集类 继承Aggregate

class ConcreteAggregate : Aggregate
    {
        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); }
        }
    }

客户端代码

static void Main(string[] args)
        {
            ConcreteAggregate a = new ConcreteAggregate();

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

            Iterator i = new ConcreteIterator(a);
            //Iterator i = new ConcreteIteratorDesc(a);
            object item = i.First();
            while (!i.IsDone())
            {
                Console.WriteLine("{0} 请买车票!", i.CurrentItem());
                i.Next();
            }

            Console.Read();
        }

效果图

优点

1.可以使用不同的方式遍历一个聚合对象，在同一聚合对象上可以定义多种遍历方式
2.简化聚合类

缺点

1.在增加新的聚合类时需要对应地增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性
2.抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展。

适用环境

访问一个聚合对象的内容而无须暴露它的内部表示
需要为一个聚合对象提供多种遍历方式
为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而在客户端可以一致性的操作该接口

再举例

我们的生活中也经常会用到迭代器模式，例如、点钞机（把所有的钱遍历一遍，得到的总数）、体育课中的报数....