内容字号:默认大号超大号

段落设置:段首缩进取消段首缩进

字体设置:切换到微软雅黑切换到宋体

设计模式实战:迭代器模式

2018-10-08 17:20 出处:清屏网 人气: 评论(0

1 概念

定义

类型

  • 迭代器模式(Iterator Pattern)

    目前已经是一个没落的模式,基本上没人会单独写一个迭代器,除非是产品性质的开发,其定义如下:

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.(它提供一种方法访问一个容器对象中各个元素,而又不需暴露该对象的内部细节。)

迭代器是为容器服务的,那什么是容器呢? 能容纳对象的所有类型都可以称之为容器,例如Collection集合类型、Set类型等,迭代器模式就是为解决遍历这些容器中的元素而诞生的

迭代器模式的通用类图

迭代器模式提供了遍历容器的方便性,容器只要管理增减元素就可以了,需要遍历时交由迭代器进行

看看迭代器模式中的各个角色:

  • Iterator抽象迭代器
    抽象迭代器负责定义访问和遍历元素的接口,而且基本上是有固定的3个方法:
    • first()获得第一个元素
    • next()访问下一个元素
    • hasNext()是否已经访问到底部
  • ConcreteIterator具体迭代器
    具体迭代器角色要实现迭代器接口,完成容器元素的遍历。
  • Aggregate抽象容器
    容器角色负责提供创建具体迭代器角色的接口,必然提供一个类似createIterator()这样的方法,在Java中一般是iterator()方法。
  • Concrete Aggregate具体容器
    具体容器实现容器接口定义的方法,创建出容纳迭代器的对象。

我们来看迭代器模式的通用源代码

  • 抽象迭代器
public interface Iterator<E> {

    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     * Performs the given action for each remaining element until all elements
     * have been processed or the action throws an exception.  Actions are
     * performed in the order of iteration, if that order is specified.
     * Exceptions thrown by the action are relayed to the caller.
     *
     * @implSpec
     * <p>The default implementation behaves as if:
     * <pre>{@code
     *     while (hasNext())
     *         action.accept(next());
     * }</pre>
     *
     * @param action The action to be performed for each element
     * @throws NullPointerException if the specified action is null
     * @since 1.8
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}
  • 具体迭代器
public class ConcreteIterator implements Iterator {
     private Vector vector = new Vector();
     //定义当前游标
     public int cursor = 0;
     @SuppressWarnings("unchecked")
     public ConcreteIterator(Vector _vector){
             this.vector = _vector;
     }
     //判断是否到达尾部
     public boolean hasNext() {
             if(this.cursor == this.vector.size()){
                    return false;
             }else{
                    return true;
             }
     }
     //返回下一个元素
     public Object next() {
             Object result = null;
             if(this.hasNext()){
                    result = this.vector.get(this.cursor++);
             }else{
                    result = null;
             }
             return result;
     }
     //删除当前元素
     public boolean remove() {
             this.vector.remove(this.cursor);
             return true;
     }
}

开发系统时,迭代器的删除方法应该完成两个逻辑

  • 删除当前元素

  • 当前游标指向下一个元素

  • 抽象容器

public interface Aggregate {
     //是容器必然有元素的增加
     public void add(Object object);
     //减少元素
     public void remove(Object object);
     //由迭代器来遍历所有的元素
     public Iterator iterator();
}
  • 具体容器
public class ConcreteAggregate implements Aggregate {
     //容纳对象的容器
     private Vector vector = new Vector();
     //增加一个元素
     public void add(Object object) {
             this.vector.add(object);
     }
     //返回迭代器对象
     public Iterator iterator() {
             return new ConcreteIterator(this.vector);
     }
     //删除一个元素
     public void remove(Object object) {
             this.remove(object);
     }
}
  • 场景类
public class Client {
     public static void main(String[] args) {
             //声明出容器
             Aggregate agg = new ConcreteAggregate();
             //产生对象数据放进去
             agg.add("abc");
             agg.add("aaa");
             agg.add("1234");     
             //遍历一下
             Iterator iterator = agg.iterator();
             while(iterator.hasNext()){
                     System.out.println(iterator.next());
             }
     }
}

简单地说,迭代器就类似于一个数据库中的游标,可以在一个容器内上下翻滚,遍历所有它需要查看的元素。

2 适用场景

3 优点

4 缺点

相关模式

实例

现在还在开发或者维护的103个项目,项目信息很乱,很多是两年前的信息,你能不能先把这些项目最新情况重新打印一份给我,咱们好查查到底有什么问题

项目信息类图

简单得不能再简单的类图,是个程序员都能实现。我们来看看这个简单的东西

  • 项目信息接口
public interface IProject {
     //从老板这里看到的就是项目信息
     public String getProjectInfo();
}
  • 项目信息的实现
public class Project implements IProject {
     //项目名称
     private String name = "";
     //项目成员数量
     private int num = 0;
     //项目费用
     private int cost = 0;
     //定义一个构造函数,把所有老板需要看到的信息存储起来
     public Project(String name,int num,int cost){
             //赋值到类的成员变量中
             this.name = name;
             this.num = num;
             this.cost=cost;
     }
     //得到项目的信息
     public String getProjectInfo() {
             String info = "";
             //获得项目的名称
             info = info+ "项目名称是:" + [this.name](http://this.name/);
             //获得项目人数
             info = info + "\t项目人数: "+ this.num;
             //项目费用
             info = info+ "\t 项目费用:"+ this.cost;
             return info;
     }
}

通过构造函数把要显示的数据传递过来,然后放到getProjectInfo中显示

  • 报表的场景
public class Boss {
             public static void main(String[] args) {
                     //定义一个List,存放所有的项目对象
                     ArrayList projectList = new ArrayList();
                     //增加星球大战项目
                     projectList.add(new Project("星球大战项目",10,100000));
                     //增加扭转时空项目
                     projectList.add(new Project("扭转时空项目",100,10000000));
                     //增加超人改造项目
                     projectList.add(new Project("超人改造项目",10000,1000000000));
                     //这边100个项目
                     for(int i=4;i<104;i++){
                             projectList.add(new Project("第"+i+"个项目",i*5,i*1000000));
                     }
                     //遍历一下ArrayList,把所有的数据都取出
                     for(IProject project:projectList){
             System.out.println(project.getProjectInfo());
                                        }
             }
}

然后看一下我们的运行结果,如下所示:

又看了一遍程序,应该还有另外一种实现方式,因为是遍历嘛,让我想到的就是Java的迭代器接口java.util.iterator,它的作用就是遍历Collection集合下的元素,那我们的程序还可以有另外一种实现,通过实现iterator接口来实现遍历

增加迭代接口的类图

看着是不是复杂了很多?是的,是有点复杂了,是不是我们把简单的事情复杂化了?

我们先分析一下我们的类图java.util.Iterator接口中声明了三个方法,这是JDK定义的, ProjectIterator 实现该接口,并且聚合了Project对象,也就是把Project对象作为本对象的成员变量使用。看类图还不是很清晰,我们一起看一下代码,先看IProject接口的改变

  • 项目信息接口
public interface IProject {
     //增加项目
     public void add(String name,int num,int cost);
     //从老板这里看到的就是项目信息
     public String getProjectInfo();
     //获得一个可以被遍历的对象
     public IProjectIterator iterator();
}

这里多了两个方法,一个是add方法,这个方法是增加项目,也就是说产生了一个对象后,直接使用add方法增加项目信息。我们再来看其实现类

  • 项目信息
public class Project implements IProject {
     //定义一个项目列表,说有的项目都放在这里
     private ArrayList projectList = new ArrayList();
     //项目名称
     private String name = "";
     //项目成员数量
     private int num = 0;
     //项目费用
     private int cost = 0;
     public Project(){

     }
     //定义一个构造函数,把所有老板需要看到的信息存储起来
     private Project(String name,int num,int cost){
             //赋值到类的成员变量中
             [this.name](http://this.name/) = name;
             this.num = num;
             this.cost=cost;
     }
     //增加项目
     public void add(String name,int num,int cost){
             this.projectList.add(new Project(name,num,cost));
     }
     //得到项目的信息
     public String getProjectInfo() {
             String info = "";
             //获得项目的名称
             info = info+ "项目名称是:" + [this.name](http://this.name/);
             //获得项目人数
             info = info + "\t项目人数: "+ this.num;
             //项目费用
             info = info+ "\t 项目费用:"+ this.cost;
             return info;
     }
     //产生一个遍历对象
     public IProjectIterator iterator(){
             return new ProjectIterator(this.projectList);
     }
}

通过构造函数,传递了一个项目所必需的信息,然后通过iterator()方法,把所有项目都返回到一个迭代器中。Iterator()方法看不懂不要紧,继续向下阅读。再看IProjectIterator接口

  • 项目迭代器接口
public interface IProjectIterator extends Iterator {
}

大家可能对该接口感觉很奇怪,你定义的这个接口方法、变量都没有,有什么意义呢?有意义,所有的Java书上都会说要面向接口编程,你的接口是对一个事物的描述,也就是说我通过接口就知道这个事物有哪些方法,哪些属性,我们这里的IProjectIterator是要建立一个指向Project类的迭代器,目前暂时定义的就是一个通用的迭代器,可能以后会增加IProjectIterator的一些属性或者方法。当然了,你也可以在实现类上实现两个接口,一个是Iterator,一个是IProjectIterator(这时候,这个接口就不用继承Iterator),杀猪杀尾巴,各有各的杀法。

如果我要实现一个容器或者其他API提供接口时,我一般都自己先写一个接口继承,然后再继承自己写的接口,保证自己的实现类只用实现自己写的接口(接口传递,当然也要实现顶层的接口)

我们继续看迭代器的实现类

  • 项目迭代器
public class ProjectIterator implements IProjectIterator {
     //所有的项目都放在ArrayList中
     private ArrayList projectList = new ArrayList();
     private int currentItem = 0; 
     //构造函数传入projectList
     public ProjectIterator(ArrayList projectList){
             this.projectList = projectList;
     }
     //判断是否还有元素,必须实现
     public boolean hasNext() {
             //定义一个返回值
             boolean b = true;
             if(this.currentItem>=projectList.size()||this.projectList.get(this.currentItem)==null){
                  b =false;
          }
             return b;
     }
     //取得下一个值
     public IProject next() {
             return (IProject)this.projectList.get(this.currentItem++);
     }
     //删除一个对象
     public void remove() {
             //暂时没有使用到
     }
}

细心的读者可能会从代码中发现一个问题,java.util.iterator接口中定义next()方法的返回值类型是E,而你在ProjectIterator中返回值却是IProject,E和IProject有什么关系?

E是JDK 1.5中定义的新类型:元素(Element),是一个泛型符号,表示一个类型,具体什么类型是在实现或运行时决定,总之它代表的是一种类型,你在这个实现类中把它定义为ProjectIterator,在另外一个实现类可以把它定义为String,都没有问题。它与Object这个类可是不同的,Object是所有类的父类,随便一个类你都可以把它向上转型到Object类,也只是因为它是所有类的父类,它才是一个通用类,而E是一个符号,代表所有的类,当然也代表Object了。

都写完毕了,看看我们的Boss类有多少改动

  • 老板看报表
public class Boss {
             public static void main(String[] args) {
                     //定义一个List,存放所有的项目对象
                     IProject project = new Project();
                     //增加星球大战项目
                     project.add("星球大战项目ddddd",10,100000);
                     //增加扭转时空项目
                     project.add("扭转时空项目",100,10000000);
                     //增加超人改造项目
                     project.add("超人改造项目",10000,1000000000);
                     //这边100个项目
                     for(int i=4;i<104;i++){
                             project.add("第"+i+"个项目",i*5,i*1000000);
                     }
                     //遍历一下ArrayList,把所有的数据都取出
                     IProjectIterator projectIterator = project.iterator();
                     while(projectIterator.hasNext()){
                             IProject p = (IProject)projectIterator.next();
                             System.out.println(p.getProjectInfo());
                     }
             }
}

运行结果如下所示

分享给小伙伴们:
本文标签: 设计模式迭代器模式

相关文章

发表评论愿您的每句评论,都能给大家的生活添色彩,带来共鸣,带来思索,带来快乐。

CopyRight © 2015-2016 QingPingShan.com , All Rights Reserved.

清屏网 版权所有 豫ICP备15026204号