zoukankan      html  css  js  c++  java
  • 迭代器模式(Iterator)

    迭代器模式(Iterator)

    1.模式动机

    在现实生活以及程序设计中,经常要访问一个聚合对象中的各个元素,如“数据结构”中的链表遍历,通常的做法是将链表的创建和遍历都放在同一个类中,但这种方式不利于程序的扩展,如果要更换遍历方法就必须修改程序源代码,这违背了 “开闭原则”。

    既然将遍历方法封装在聚合类中不可取,那么聚合类中不提供遍历方法,将遍历方法由用户自己实现是否可行呢?答案是同样不可取,因为这种方式会存在两个缺点:

    1. 暴露了聚合类的内部表示,使其数据不安全;
    2. 增加了客户的负担。

    “迭代器模式”能较好地克服以上缺点,它在客户访问类与聚合类之间插入一个迭代器,这分离了聚合对象与其遍历行为,对客户也隐藏了其内部细节,且满足“单一职责原则”和“开闭原则”,如Java中的 Collection、List、Set、Map 等都包含了迭代器。

    2.模式定义

    迭代器(Iterator)模式的定义:提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。迭代器模式是一种对象行为型模式

    3.模式结构

    1. 迭代器模式主要包含以下角色。
      1. 抽象聚合(Aggregate)角色:定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
      2. 具体聚合(ConcreteAggregate)角色:实现抽象聚合类,返回一个具体迭代器的实例。
      3. 抽象迭代器(Iterator)角色:定义访问和遍历聚合元素的接口,通常包含 hasNext()、first()、next() 等方法。
      4. 具体迭代器(Concretelterator)角色:实现抽象迭代器接口中所定义的方法,完成对聚合对象的遍历,记录遍历的当前位置。

    4.代码分析

    //抽象聚合
    interface Aggregate
    { 
        public void add(Object obj); 
        public void remove(Object obj); 
        public Iterator getIterator(); 
    }
    //具体聚合
    class ConcreteAggregate implements Aggregate
    { 
        private List<Object> list=new ArrayList<Object>(); 
        public void add(Object obj)
        { 
            list.add(obj); 
        }
        public void remove(Object obj)
        { 
            list.remove(obj); 
        }
        public Iterator getIterator()
        { 
            return(new ConcreteIterator(list)); 
        }     
    }
    //抽象迭代器
    interface Iterator
    {
        Object first();
        Object next();
        boolean hasNext();
    }
    //具体迭代器
    class ConcreteIterator implements Iterator
    { 
        private List<Object> list=null; 
        private int index=-1; 
        public ConcreteIterator(List<Object> list)
        { 
            this.list=list; 
        } 
        public boolean hasNext()
        { 
            if(index<list.size()-1)
            { 
                return true;
            }
            else
            {
                return false;
            }
        }
        public Object first()
        {
            index=0;
            Object obj=list.get(index);;
            return obj;
        }
        public Object next()
        { 
            Object obj=null; 
            if(this.hasNext())
            { 
                obj=list.get(++index); 
            } 
            return obj; 
        }   
    }
    public class IteratorPattern
    {
        public static void main(String[] args)
        {
            Aggregate ag=new ConcreteAggregate(); 
            ag.add("中山大学"); 
            ag.add("华南理工"); 
            ag.add("韶关学院");
            System.out.print("聚合的内容有:");
            Iterator it=ag.getIterator(); 
            while(it.hasNext())
            { 
                Object ob=it.next(); 
                System.out.print(ob.toString()+"	"); 
            }
            Object ob=it.first();
            System.out.println("
    First:"+ob.toString());
        }
    }
    

    5.模式分析

    迭代器模式是通过将聚合对象的遍历行为分离出来,抽象成迭代器类来实现的,其目的是在不暴露聚合对象的内部结构的情况下,让外部代码透明地访问聚合的内部数据。

    6.实例

    桂林的景点较多,要设计一个查看相关景点图片和简介的程序,用“迭代器模式”设计比较合适。

    7.优缺点

    优点:
    • 访问一个聚合对象的内容而无须暴露它的内部表示。
    • 遍历任务交由迭代器完成,这简化了聚合类。
    • 它支持以不同方式遍历一个聚合,甚至可以自定义迭代器的子类以支持新的遍历。
    • 增加新的聚合类和迭代器类都很方便,无须修改原有代码。
    • 封装性良好,为遍历不同的聚合结构提供一个统一的接口。
    缺点:
    • 增加了类的个数,这在一定程度上增加了系统的复杂性。
    适用环境:
    • 当需要为聚合对象提供多种遍历方式时。
    • 当需要为遍历不同的聚合结构提供一个统一的接口时。
    • 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

    8.模式扩展

    迭代器模式常常与组合模式结合起来使用,在对组合模式中的容器构件进行访问时,经常将迭代器潜藏在组合模式的容器构成类中。当然,也可以构造一个外部迭代器来对容器构件进行访问

  • 相关阅读:
    461. Hamming Distance
    342. Power of Four
    326. Power of Three
    368. Largest Divisible Subset java solutions
    95. Unique Binary Search Trees II java solutions
    303. Range Sum Query
    160. Intersection of Two Linked Lists java solutions
    88. Merge Sorted Array java solutions
    67. Add Binary java solutions
    14. Longest Common Prefix java solutions
  • 原文地址:https://www.cnblogs.com/s841844054/p/14031048.html
Copyright © 2011-2022 走看看