首页 > 代码库 > 大话设计模式_迭代器模式(Java代码)

大话设计模式_迭代器模式(Java代码)

2024-07-07 14:12:29   229人阅读

迭代器模式：提供一个方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示

简单描述：提供一个单独的接口遍历聚集类对象中的成员，以实现聚集对象的隐藏和内部数据供外部访问

大话设计模式中的截图：

我觉得以上面的图示进行编码会暴露ConcreteAggregate中的内部信息(ConcreteIerator可以访问聚集类中的成员，那表示其他类也可以和ConcreteIerator一样进行相同的访问)，所以我以另外一种形式实现迭代器(即内部类的方式，和Java中的ArrayList类似)

代码例子：

AbstractIterator类：

 1 package com.longsheng.iterator;
 2 
 3 public abstract class AbstractIterator {
 4 
 5     public abstract Object first();
 6 
 7     public abstract Object next();
 8 
 9     public abstract boolean isDone();
10 
11     public abstract Object currentItem();
12 
13 }

AbstractAggregate类：

1 package com.longsheng.iterator;
2 
3 public abstract class AbstractAggregate {
4 
5     public abstract AbstractIterator getIterator();
6     
7 }

ConcreteAggregate类：

 1 package com.longsheng.iterator;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class ConcreteAggregate extends AbstractAggregate {
 7 
 8     private List<Object> container = new ArrayList<Object>();
 9 
10     @Override
11     public AbstractIterator getIterator() {
12         return new ConcreteIterator();
13     }
14 
15     public void add(Object mObject) {
16         container.add(mObject);
17     }
18 
19     public void remove(Object mObject) {
20         container.remove(mObject);
21     }
22 
23     private class ConcreteIterator extends AbstractIterator {
24 
25         int currentPosition = 0;
26 
27         @Override
28         public Object first() {
29             if (container.size() > 0) {
30                 return container.get(0);
31             }
32             return null;
33         }
34 
35         @Override
36         public Object next() {
37             int index = currentPosition++;
38             if (index < container.size()) {
39                 return container.get(index);
40             }
41             return null;
42         }
43 
44         @Override
45         public boolean isDone() {
46             if( currentPosition >= container.size() ) {
47                 return true;
48             }
49             return false;
50         }
51 
52         @Override
53         public Object currentItem() {
54             if( currentPosition < container.size() ){
55                 return container.get(currentPosition);
56             }
57             return null;
58         }
59 
60     }
61 }

客户端类：

 1 package com.longsheng.iterator;
 2 
 3 public class Client {
 4 
 5     public static void main(String args[]) {
 6         ConcreteAggregate mAggregate = new ConcreteAggregate();
 7         mAggregate.add("大鸟");
 8         mAggregate.add("小菜");
 9         mAggregate.add("行李");
10         mAggregate.add("老外");
11         mAggregate.add("公交内部员工");
12         mAggregate.add("小偷");
13         
14         AbstractIterator mIterator = mAggregate.getIterator();
15         while( mIterator.isDone() == false ) {
16             System.out.println(mIterator.next() + ",请买车票");
17         }
18     }
19 
20 }

运行结果：

1 大鸟,请买车票
2 小菜,请买车票
3 行李,请买车票
4 老外,请买车票
5 公交内部员工,请买车票
6 小偷,请买车票

当需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，或者需要对聚集对象有多种遍历方式时，就应该考虑用迭代器模式。

迭代器模式分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明的访问集合内部的数据


联系
我们