迭代器（Iterator）模式

最新推荐文章于 2024-04-19 15:54:37 发布

转载最新推荐文章于 2024-04-19 15:54:37 发布 · 1k 阅读

design pattern 专栏收录该内容

23 篇文章

订阅专栏

本文深入探讨迭代器模式的概念、适用场景，并通过代码实例展示了如何实现迭代器模式，包括迭代器抽象类、具体迭代器类、聚集抽象类及其实现，以及客户端如何使用迭代器模式进行操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概述：

迭代器模式(Iterator)：提供一种方法顺序一个聚合对象中各个元素，而又不暴露该对象内部表示。

实用场合：

1.访问一个聚合对象的内容而无需暴露它的内部表示。

2.支持对聚合对象的多种遍历。

3.为遍历不同的聚合结构提供一个统一的接口(即，多态迭代)。

类图：

代码结构示例：

1.迭代器抽象类

    /// <summary>
    /// 迭代器抽象类
    /// 用于定义得到的开始对象，下一个对象，是否到结尾，当前对象方法，统一接口
    /// </summary>
    abstract class Iterator
    {
        public abstract object First();

        public abstract object Next();

        public abstract bool IsDone();

        public abstract object CurrentItem();
    }

2.实现迭代器类

    class ConcreteIterator:Iterator
    {
        /// <summary>
        /// 定义了一个具体聚集对象
        /// </summary>
        private ConcreteAggregate aggregate;

        private int current = 0;
        /// <summary>
        /// 初始化对象将具体聚集类传入
        /// </summary>
        /// <param name="aggregate"></param>
        public ConcreteIterator(ConcreteAggregate aggregate) 
        {
            this.aggregate = aggregate;
        }
        /// <summary>
        /// 第一个对象
        /// </summary>
        /// <returns></returns>
        public override object First()
        {
            return aggregate[0];
        }
        /// <summary>
        /// 得到聚集的下一对象
        /// </summary>
        /// <returns></returns>
        public override object Next()
        {
            object ret = null;
            current++;
            if(current<aggregate.Count)
            {
                ret = aggregate[current];
            }
            return ret;
        }
        /// <summary>
        /// 是否到结尾
        /// </summary>
        /// <returns></returns>
        public override bool IsDone()
        {
            return current >= aggregate.Count ? true : false;
        }
        /// <summary>
        /// 返回当前聚集对象
        /// </summary>
        /// <returns></returns>
        public override object CurrentItem()
        {
            return aggregate[current];
        }
    }

3.聚集抽象类

    /// <summary>
    /// 聚集抽象类
    /// </summary>
    abstract class Aggregate
    {
        /// <summary>
        /// 创建迭代器
        /// </summary>
        /// <returns></returns>
        public abstract Iterator CreateIterator();
    }

4.聚集实现类

    class ConcreteAggregate:Aggregate
    {
        private IList<object> items = new List<object>();

        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }
        /// <summary>
        /// 返回聚集总个数
        /// </summary>
        public int Count 
        {
            get { return items.Count; }
        }
        /// <summary>
        /// 声明一个索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public object this[int index] 
        {
            get { return items[index]; }
            set { items.Insert(index, value); }
        }
    }

5.客户端实现

        /// <summary>
        /// 测试迭代器模式
        /// </summary>
        static void TestIterator() 
        {
            //聚集对象
            ConcreteAggregate a = new ConcreteAggregate();

            a[0] = "张三";
            a[1] = "李四"; 
            a[2] = "叶鹏";
            //声明迭代器对象
            Iterator i = new ConcreteIterator(a);

            object item = i.First();
            while(!i.IsDone())
            {
                Console.WriteLine("{0}回家吃饭",i.CurrentItem());
                i.Next();
            }
            Console.Read();
        }

AbstractList中迭代器模式的实现：

//迭代器角色，仅仅定义了遍历接口

public interface Iterator {
　boolean hasNext();
　Object next();
　void remove();
}

//容器角色，这里以List为例。它也仅仅是一个接口，就不罗列出来了
//具体容器角色，便是实现了List接口的ArrayList等类。为了突出重点这里指罗列和迭代器相关的内容
//具体迭代器角色，它是以内部类的形式出来的。AbstractList是为了将各个具体容器角色的公共部分提取出来而存在的。

public abstract class AbstractList extends AbstractCollection implements List {
…… 
//这个便是负责创建具体迭代器角色的工厂方法
public Iterator iterator() {
　return new Itr();
}

//作为内部类的具体迭代器角色

private class Itr implements Iterator {
　int cursor = 0;
　int lastRet = -1;
　int expectedModCount = modCount;

　public boolean hasNext() {
　　return cursor != size();
　}

　public Object next() {
　　checkForComodification();
　　try {
　　　Object next = get(cursor);
　　　lastRet = cursor++;
　　　return next;
　　} catch(IndexOutOfBoundsException e) {
　　　checkForComodification();
　　　throw new NoSuchElementException();
　　}
　}

　public void remove() {
　　if (lastRet == -1)
　　　throw new IllegalStateException();
　　　checkForComodification();

　　try {
　　　AbstractList.this.remove(lastRet);
　　　if (lastRet < cursor)
　　　　cursor--;
　　　lastRet = -1;
　　　expectedModCount = modCount;
　　} catch(IndexOutOfBoundsException e) {
　　　throw new ConcurrentModificationException();
　　}
　}

　final void checkForComodification() {
　　if (modCount != expectedModCount)
　　　throw new ConcurrentModificationException();
　}
}

ref: http://www.cnblogs.com/jqbird/archive/2011/08/31/2160653.html