iOS 迭代器模式

迭代器模式: 就是遍历集合类，数组，字典都有枚举器遍历的方法，其实就是cocoa实现的迭代器模式

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

       当你需要访问一个聚合对象，而且不管这些对象是什么都需要遍历的时候，就应该考虑使用迭代器模式。另外，当需要对聚集有多种方式遍历时，可以考虑去使用迭代器模式。迭代器模式为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。

迭代器模式UML类图：

 

迭代器模式实现：

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Iterator  
{  
    /*Iterator迭代器抽象类*/  
    abstract  class Iterator  
    {  
        public abstract object First();  
        public abstract object Next();  
        public abstract object CurrentItem();  
        public abstract bool IsDone();  
    }  
    /*Aggregate聚集抽象类*/  
    abstract class Aggregate  
    {  
        public abstract Iterator createIterator();  
    }  
  
    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 bool IsDone()  
        {  
            return current >= aggregate.Count ? true : false;  
        }  
  
        // 返回当前聚集对象  
        public override object CurrentItem()  
        {  
            return aggregate[current];  
        }  
    }  
  
    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); }  
        }  
    }  
}  

客户端：

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Iterator  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            ConcreteAggregate ca = new ConcreteAggregate();  
            ca[0] = "大鸟";  
            ca[1] = "小菜";  
            ca[2] = "行李";  
            ca[3] = "老外";  
            ca[4] = "公交内部员工";  
            ca[5] = "小偷";  
  
            Iterator i = new ConcreteIterator(ca);  
            object obj = i.First();  
            while (!i.IsDone())  
            {  
                Console.WriteLine("{0}  请买车票！",i.CurrentItem());  
                i.Next();  
            }  
            Console.Read();  
        }  
    }  
}  

运行结果：

迭代器模式总结：

迭代器模式（Iterator）就是分离了聚合对象的遍历行为，抽象出一个迭代器来负责这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部数据。

迭代器模式在访问数组、集合、列表等数据时,是非常普遍的应用,但由于它太普遍了,所以各种高级语言都对它进行了封装,所以反而给人感觉此模式本身不太常用了。

现今来看迭代器模式实用价值远不如学习价值大了,Martin Flower甚至在自己的网站上提出撤销此模式。因为现在高级编程语言已经把这个模式做在语言中了, 不管如何,学习一下GoF的迭代器模式的基本结构,还是很有学习价值的。研究历史是为了更好地迎接未来。