设计模式14 - 迭代器模式【Iterator Pattern】

简介: 设计模式14 - 迭代器模式【Iterator Pattern】

迭代器模式

已经过时了,随便看看吧,下面的代码都是复制过来的。

定义:

提供一种方法顺序访问一个聚合对象中的各种元素,而又不暴露该对象的内部表示。

举例:

未修改前的代码:

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; 
         //获得项目人数
         info = info + "\t项目人数: "+ this.num; 
         //项目费用
         info = info+ "\t 项目费用:"+ this.cost; 
         return info; 
     } 
} 
public class Boss { 
     public static void main(String[] args) { 
         //定义一个List,存放所有的项目对象
         ArrayList<IProject> projectList = new ArrayList<IProject>(); 
         //增加星球大战项目
         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()); 
         } 
     } 
} 

修改之后的代码:

public interface IProject { 
    //增加项目
    public void add(String name,int num,int cost); 
    //从老板这里看到的就是项目信息
    public String getProjectInfo(); 
    //获得一个可以被遍历的对象
    public IProjectIterator iterator(); 
} 
public class Project implements IProject { 
    //定义一个项目列表,说有的项目都放在这里
    private ArrayList<IProject> projectList = new ArrayList<IProject>(); 
    //项目名称
    private String name = ""; 
    //项目成员数量
    private int num = 0; 
    //项目费用
    private int cost = 0; 
    public Project(){} 
    //定义一个构造函数,把所有老板需要看到的信息存储起来
    private Project(String name,int num,int cost){ 
         //赋值到类的成员变量中
         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; 
         //获得项目人数
         info = info + "\t项目人数: "+ this.num; 
         //项目费用
         info = info+ "\t 项目费用:"+ this.cost; 
         return info; 
     } 
    //产生一个遍历对象
    public IProjectIterator iterator(){ 
         return new ProjectIterator(this.projectList); 
    } 
} 
public interface IProjectIterator extends Iterator { 
}
public class ProjectIterator implements IProjectIterator { 
    //所有的项目都放在这里ArrayList中
    private ArrayList<IProject> projectList = new ArrayList<IProject>(); 
    private int currentItem = 0; 
    //构造函数传入projectList
    public ProjectIterator(ArrayList<IProject> 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() { 
         //暂时没有使用到
    } 
} 
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()); 
     } 
  } 
 } 

总结:

基本上很少有项目再独立写迭代器了,直接使用 List 或者 Map 就可以完整的解决问题。

目录
相关文章
|
3月前
|
设计模式 算法 Java
行为型设计模式-策略模式(Strategy Pattern)
行为型设计模式-策略模式(Strategy Pattern)
|
4天前
|
设计模式 Go
[设计模式 Go实现] 行为型~迭代器模式
[设计模式 Go实现] 行为型~迭代器模式
|
3月前
|
设计模式 算法
设计模式 - 行为型模式_ 访问者模式Visitor Pattern
设计模式 - 行为型模式_ 访问者模式Visitor Pattern
39 1
设计模式 - 行为型模式_ 访问者模式Visitor Pattern
|
3月前
|
设计模式 Java 应用服务中间件
设计模式 -结构型模式_门面模式(外观模式) Facade Pattern 在开源软件中的应用
设计模式 -结构型模式_门面模式(外观模式) Facade Pattern 在开源软件中的应用
31 1
|
3月前
|
设计模式 缓存 安全
设计模式 - 创建型模式_ 单例模式 Singleton Pattern
设计模式 - 创建型模式_ 单例模式 Singleton Pattern
39 0
|
14天前
|
设计模式 存储 Java
Java设计模式:解释一下单例模式(Singleton Pattern)。
`Singleton Pattern`是Java中的创建型设计模式,确保类只有一个实例并提供全局访问点。它通过私有化构造函数,用静态方法返回唯一的实例。类内静态变量存储此实例,对外仅通过静态方法访问。
16 1
|
16天前
|
设计模式 Java
小谈设计模式(21)—迭代器模式
小谈设计模式(21)—迭代器模式
|
1月前
|
设计模式 存储 算法
【设计模式】迭代器模式
【设计模式】迭代器模式
|
3月前
|
设计模式 Java 数据挖掘
聊聊Java设计模式-迭代器模式
迭代器(Iterator)模式,也叫做游标(Cursor)模式。我们知道,在Java 容器中,为了提高容器遍历的方便性,我们利用迭代器把遍历逻辑从不同类型的集合类中抽取出来,从而避免向外部暴露集合容器的内部结构。
44 0
聊聊Java设计模式-迭代器模式
|
3月前
|
设计模式 算法 Go
Golang设计模式——07迭代器模式
Golang设计模式——07迭代器模式
24 0