一天学习一个设计模式之迭代器模式

Posted gousheng107

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了一天学习一个设计模式之迭代器模式相关的知识,希望对你有一定的参考价值。

迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露该对象的内部表示。
当需要访问一个聚集对象,而且不管这些对象是什么都需要遍历的时候,就应该考虑用迭代器模式,需要对聚集有多种方式遍历时,也可以考虑用迭代器模式。为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一接口。
迭代器模式就是分离了集合对象的遍历行为,抽象出一个迭代器来负责,这样既可以做到不暴露集合的内部结构,又可让外部透明地访问集合内部的数据。

 

  技术分享图片

代码如下:

 1 /**
 2  * 迭代器抽象类
 3  */
 4 public abstract class Iterator {
 5     /**
 6      * 迭代方法:移动到第一个元素
 7      * @return
 8      */
 9     public abstract Object first();
10 
11     /**
12      * 迭代方法:移动到下一个元素
13      * @return
14      */
15     public abstract Object next();
16 
17     /**
18      * 用于定义得到开始对象、得到下一个对象、判断
19      * 是否到结尾、当前对象等抽象方法,统一接口
20      * 迭代方法:是否为最后一个元素
21      * @return
22      */
23     public abstract boolean isDone();
24 
25     /**
26      * 迭代方法:返还当前元素
27      * @return
28      */
29     public abstract Object currentItem();
30 }
 1 /**
 2  * 具体迭代器类继承迭代器抽象类
 3  */
 4 public class ConcreteIterator extends Iterator {
 5 
 6     /**
 7      * 定义了一个具体聚集对象
 8      */
 9     private ConcreteAggregate aggregate;
10     private int current=0;
11 
12     public ConcreteIterator(ConcreteAggregate aggregate) {
13        this.aggregate=aggregate;
14     }
15 
16     /**
17      * 得到聚集的第一个对象
18      * @return
19      */
20     @Override
21     public Object first() {
22         return aggregate.getElement(0);
23     }
24 
25     /**
26      * 得到聚集的下一个对象
27      * @return
28      */
29     @Override
30     public Object next() {
31         Object ret=null;
32         current++;
33         if (current<aggregate.getCount())
34         {
35             ret=aggregate.getCount();
36         }
37         return ret;
38     }
39 
40     /**
41      * 判断当前是否遍历到结尾,到结尾返回true
42      * @return
43      */
44     @Override
45     public boolean isDone() {
46         return current>=aggregate.getCount()?true:false;
47     }
48 
49     @Override
50     public Object currentItem() {
51         return aggregate.getElement(current);
52     }
53 }
1 /**
2  * 聚集抽象类
3  */
4 public abstract class Aggregate {
5     public abstract Iterator createIterator();
6 }
 1 /**
 2  * 具体聚集类继承聚集抽象类
 3  */
 4 public class ConcreteAggregate extends Aggregate {
 5 
 6     /**
 7      * 声明一个List泛型变量,用于存放聚合对象,用ArrayList同样可以实现
 8      */
 9     private List<Object> items=new ArrayList<>();
10 
11     public ConcreteAggregate(List<Object> list) {
12         this.items=list;
13     }
14 
15     @Override
16     public Iterator createIterator() {
17         return new ConcreteIterator(this);
18     }
19 
20     /**
21      * 返回聚集总个数
22      * @return
23      */
24     public int getCount() {
25         return items.size();
26     }
27 
28     /**
29      * 取值方法:向外界提供聚集元素
30      */
31     public Object getElement(int index){
32         if (index<getCount()){
33             return items.get(index);
34         }
35         else {
36             return null;
37         }
38     }
39 }
 1 public class Client {
 2     public static void main(String[] args) {
 3 
 4         List<Object> list=new ArrayList<>();
 5         list.add("大鸟");
 6         list.add("小菜");
 7         list.add("行李");
 8         list.add("老外");
 9         list.add("公交内部员工");
10         list.add("小偷");
11 
12         ConcreteAggregate a=new ConcreteAggregate(list);
13         Iterator i=a.createIterator();
14         Object item=i.first();
15         System.out.println("第1:"+item.toString());
16         while (!i.isDone()){
17             System.out.println(i.currentItem()+"请买车票");
18             i.next();
19         }
20     }
21 }

 


以上是关于一天学习一个设计模式之迭代器模式的主要内容,如果未能解决你的问题,请参考以下文章

Java 设计模式之迭代器学习与掌握

Java 设计模式之迭代器学习与掌握

学习设计模式之迭代模式

设计模式之迭代器模式

一天一个设计模式——迭代器模式

设计模式学习笔记之迭代器模式