java设计模式-迭代器模式

Posted 2021-12-01 weekstart

模式导读：

       验钞机相信大家都见过吧，也就是能够快速的将一大捆钱翻检然后看是否存在假钞，如果发现假钞则停下来将它取出来。这种能够将一个聚合体，容器里面的所有对象或物品迭代搜索或者迭代取出来的模式就是迭代模式，这种模式在程序语言中经常能够接触到，并且非常实用，只不过都已经封装好了不需要我们对它进行重写。

参考类图:

因为这里使用的是静态内部类来实现直接在聚合对象里面创建具体迭代器，插件无法表示它们之间的关系，所以我直接用关联关系将它们连接起来了。

代码实现：

1.定义一个迭代器接口，给它一些迭代器应该拥有的方法

 1 package com.etc;
 2 //迭代器接口
 3 public interface AbstractIterator {
 4     //游标指向第一个元素
 5     void first();
 6     //游标指向下一个元素
 7     void next();
 8     //判断是否存在下一个
 9     boolean hasNext();
10     //获取当前游标指向的元素
11     Object getCurrentObj();
12 
13 }

2.聚合对象类，里面直接利用静态内部类实现具体迭代器的创建和获取

 1 package com.etc;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 //聚合类
 7 public class Aggregate {
 8     //定义一个list容器用于存放Object对象
 9     private List<Object> list=new ArrayList<Object>();
10     //定义一个添加元素的方法
11     public void add(Object obj) {
12         this.list.add(obj);
13     }
14     //定义一个删除元素的方法
15     public void remove(Object obj) {
16         this.list.remove(obj);
17     }
18     //获取list容器
19     public List<Object> getList() {
20         return list;
21     }
22     public void setList(List<Object> list) {
23         this.list = list;
24     }
25 
26     //获取迭代器方法
27     public AbstractIterator createIterator() {
28         return new MyIterator();
29     }
30 
31     //具体的迭代器类
32     private    class MyIterator implements  AbstractIterator {
33         //定义游标
34         private int cursor;
35         @Override
36         public void first() {
37             cursor=0;
38         }
39 
40         @Override
41         public void next() {    
42             if(cursor<list.size()) {
43                 cursor++;
44             }
45         }
46 
47         @Override
48         public boolean hasNext() {
49             //如果当前游标的值小于list容器的大小
50             if(cursor<list.size()) {
51                 return true;
52             }
53             return false;
54         }
55 
56         @Override
57         public Object getCurrentObj() {
58             //返回当前list容器对应下标为cursor的值
59             return list.get(cursor);
60         }
61     }
62 }

3.客户端类

 1 package com.etc;
 2 //客户端
 3 public class Client {
 4 
 5     public static void main(String[] args) {
 6         //聚合对象
 7         Aggregate c=new Aggregate();
 8         //添加对象值
 9         c.add("java");
10         c.add("python");
11         c.add("go");
12         //获取迭代器
13         AbstractIterator iter=c.createIterator();
14         while(iter.hasNext()){
15             //获取当前对象值
16             System.out.println(iter.getCurrentObj());
17             //迭代器游标后移一位
18             iter.next();
19         }
20     }
21 
22 }

效果截图：

适配器模式优缺点：

优点：

1、它支持以不同的方式遍历一个聚合对象。
2、迭代器简化了聚合类。
3、在同一个聚合上可以有多个遍历。
4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

适用场景：

1、访问一个聚合对象的内容而无须暴露它的内部表示。
2、需要为聚合对象提供多种遍历方式。
3、为遍历不同的聚合结构提供一个统一的接口。