经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » 设计模式 » 查看文章
大话设计模式笔记(十七)の迭代器模式
来源:cnblogs  作者:callmeDevil  时间:2019/8/19 8:52:32  对本文有异议

迭代器模式

定义

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

什么时候用?

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

UML图

模板代码

Aggregate

  1. /**
  2. * 聚集抽象类
  3. * Created by callmeDevil on 2019/8/17.
  4. */
  5. public abstract class Aggregate {
  6. // 创建迭代器
  7. public abstract Iterator createIterator();
  8. }

Iterator

  1. /**
  2. * 迭代器抽象类
  3. * Created by callmeDevil on 2019/8/17.
  4. */
  5. public abstract class Iterator {
  6. // 用于定义得到开始对象、得到下一对象、判断是否到结尾、当前对象等抽象方法
  7. public abstract Object first();
  8. public abstract Object next();
  9. public abstract boolean isDone();
  10. public abstract Object currentItem();
  11. }

ConcreteAggregate

  1. /**
  2. * 具体聚集类
  3. * Created by callmeDevil on 2019/8/17.
  4. */
  5. public class ConcreteAggregate extends Aggregate {
  6. // 存放聚合对象
  7. private List<Object> items = new ArrayList();
  8. @Override
  9. public Iterator createIterator() {
  10. return new ConcreteIterator(this);
  11. }
  12. // 返回聚集的总个数
  13. public int count() {
  14. return items.size();
  15. }
  16. // 声明一个索引器
  17. public Object get(int index) {
  18. return items.get(index);
  19. }
  20. public boolean set(Object o) {
  21. return items.add(o);
  22. }
  23. }

ConcreteIterator

  1. /**
  2. * 具体迭代器类
  3. * Created by callmeDevil on 2019/8/17.
  4. */
  5. public class ConcreteIterator extends Iterator {
  6. // 定义一个具体聚集对象
  7. private ConcreteAggregate aggregate;
  8. private int current = 0;
  9. public ConcreteIterator(ConcreteAggregate aggregate){
  10. // 初始化时将具体的聚集对象传入
  11. this.aggregate = aggregate;
  12. }
  13. @Override
  14. public Object first() {
  15. // 得到聚集的第一个对象
  16. return aggregate.get(0);
  17. }
  18. @Override
  19. public Object next() {
  20. Object ret = null;
  21. current++;
  22. if (current < aggregate.count()) {
  23. // 得到聚集的下一个对象
  24. ret = aggregate.get(current);
  25. }
  26. return ret;
  27. }
  28. @Override
  29. public boolean isDone() {
  30. // 判断当前是否遍历到结尾
  31. return current >= aggregate.count();
  32. }
  33. @Override
  34. public Object currentItem() {
  35. // 返回当前的聚集对象
  36. return aggregate.get(current);
  37. }
  38. }

测试

  1. public class Test {
  2. public static void main(String[] args) {
  3. // 公交车聚集对象
  4. ConcreteAggregate a = new ConcreteAggregate();
  5. // 新上来的乘客
  6. a.set("路飞");
  7. a.set("鸣人");
  8. a.set("一护");
  9. a.set("悟空");
  10. a.set("纳兹");
  11. a.set("琦玉");
  12. // 售票员登场,看好上车的是哪些人,即声明迭代器对象
  13. Iterator i = new ConcreteIterator(a);
  14. System.out.println(String.format("车位No.1乘客:%s", i.first()));
  15. while (!i.isDone()){
  16. System.out.println(String.format("%s 来不及解释了,快上车!", i.currentItem()));
  17. i.next();
  18. }
  19. }
  20. }

测试结果

  1. 车位No.1乘客:路飞
  2. 路飞 来不及解释了,快上车!
  3. 鸣人 来不及解释了,快上车!
  4. 一护 来不及解释了,快上车!
  5. 悟空 来不及解释了,快上车!
  6. 纳兹 来不及解释了,快上车!
  7. 琦玉 来不及解释了,快上车!

倒序遍历

ConcreteIteratorDesc

  1. /**
  2. * 倒序具体迭代器
  3. * Created by callmeDevil on 2019/8/17.
  4. */
  5. public class ConcreteIteratorDesc extends Iterator{
  6. // 定义一个具体聚集对象
  7. private ConcreteAggregate aggregate;
  8. private int current = 0;
  9. public ConcreteIteratorDesc(ConcreteAggregate aggregate){
  10. // 初始化时将具体的聚集对象传入
  11. this.aggregate = aggregate;
  12. current = aggregate.count() - 1; //不同1
  13. }
  14. @Override
  15. public Object first() {
  16. // 得到聚集的第一个对象
  17. return aggregate.get(aggregate.count() - 1); //不同2
  18. }
  19. @Override
  20. public Object next() {
  21. Object ret = null;
  22. current--; //不同3
  23. if (current >= 0) { //不同4
  24. // 得到聚集的下一个对象
  25. ret = aggregate.get(current);
  26. }
  27. return ret;
  28. }
  29. @Override
  30. public boolean isDone() {
  31. // 判断当前是否遍历到结尾
  32. return current < 0; //不同5
  33. }
  34. @Override
  35. public Object currentItem() {
  36. // 返回当前的聚集对象
  37. return aggregate.get(current);
  38. }
  39. }

测试

将顺序测试类中声明迭代器具体对象改为倒序的 ConcreteIteratorDesc 即可。

测试结果

  1. 车位No.1乘客:琦玉
  2. 琦玉 来不及解释了,快上车!
  3. 纳兹 来不及解释了,快上车!
  4. 悟空 来不及解释了,快上车!
  5. 一护 来不及解释了,快上车!
  6. 鸣人 来不及解释了,快上车!
  7. 路飞 来不及解释了,快上车!

总结

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

原文链接:http://www.cnblogs.com/call-me-devil/p/11368582.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号