设计模式之迭代器模式（Iterator Pattern）

╰半橙微兮° 2023-07-16 07:57 31阅读 0赞

文章目录

    • 一、迭代器模式的定义与特点
    • 二、角色与UML类图
      • 2.1、 代码：
        • 1、 Iterator
        • 2、 ConcreteIterator
        • 3、 Aggregate
        • 4、 ConcreteAggregate
        • 5、 Client
    • 三、大学-学院-专业的示例
      • 3.1、需求
      • 3.2、UML类图
      • 3.3、代码
        • 1、IteratorForComputerCollege（计算机学院迭代器）
        • 2、IteratorForInfoColleage（信息工程学院迭代器）
        • 3、Department（元素）
        • 4、Aggregate（聚合接口）
        • 4、AggregateForComputerCo（计算机学院聚合）
        • 5、AggregateForInfoCo（信息工程学院聚合实现类）
        • 6、OutPutImpl（输出类）
        • 7、Client
    • 四、迭代器模式在JDK中应用
      • 4.1、分析 ArrayList 使用迭代器模式
      • 4.2、分析 LinkedList 使用迭代器模式
        • 4.2.1、LinkedList.java
        • 4.2.2、AbstractSequentialList.java
        • 4.2.2、AbstractList.java

在程序设计中，经常要访问一个聚合对象中的各个元素，如数据结构中的链表进行遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。

既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点：

  1. 暴露了聚合类的内部表示，使其数据不安全；
  2. 增加了客户的负担。

“迭代器模式”能较好地克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”，如 Java 中的 Collection、List、Set、Map 等都包含了迭代器。

一、迭代器模式的定义与特点

定义：提供一个对象 来顺序访问 聚合对象 中的一系列数据，而不暴露 聚合对象 的内部表示。

迭代器模式是一种对象行为型模式。

优点：

  1. 访问一个聚合对象的内容而无须暴露它的内部表示。
  2. 遍历任务交由迭代器完成，这简化了聚合类。
  3. 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
  4. 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
  5. 封装性良好，为遍历不同的聚合结构提供一个统一的接口。

缺点：

每个聚合对象都要一个迭代器，迭代器（类）数量太多时就不好管理。

二、角色与UML类图

迭代器模式有两个主要角色，一个是 迭代器 对象，能遍历对象；另一个是聚合对象，没有遍历对象功能，但内嵌一个 迭代器 对象，通过 迭代器 来完成其内部对象的遍历。

迭代器模式的角色：

  1. Iterator（ 迭代器接口）：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
  2. Concretelterator（具体 迭代器）：实现 Iterator 中所定义的方法，完成对 ConcreteAggregate 的遍历，记录遍历的当前位置。
  3. Aggregate（聚合接口）：定义存储、添加、删除 元素 、 Iterator 的接口。
  4. ConcreteAggregate（具体 聚合器 ）：实现Aggregate 定义的方法，返回一个 Concretelterator（迭代器） 的实例。

在这里插入图片描述

2.1、 代码：

1、 Iterator

  1. /** * 迭代器 */
  2. public interface Iterator { 
  4.     Object first();
  6.     Object next();
  8.     boolean hasNext();
  9. }

2、 ConcreteIterator

  1. import java.util.List;
  3. /** * 具体迭代器 */
  4. public class ConcreteIterator implements Iterator { 
  6.     private List<Object> list = null;
  7.     private int index = -1;
  9.     public ConcreteIterator(List<Object> list) { 
  10.         this.list = list;
  11.     }
  13.     public boolean hasNext() { 
  14.         if (index < list.size() - 1) { 
  15.             return true;
  16.         } else { 
  17.             return false;
  18.         }
  19.     }
  21.     public Object first() { 
  22.         index = 0;
  23.         Object obj = list.get(index);
  24.         return obj;
  25.     }
  27.     public Object next() { 
  28.         Object obj = null;
  29.         if (this.hasNext()) { 
  30.             obj = list.get(++index);
  31.         }
  32.         return obj;
  33.     }
  34. }

3、 Aggregate

  1. /** * 聚合接口 */
  2. public interface Aggregate { 
  4.     public void add(Object obj);
  6.     public void remove(Object obj);
  8.     public Iterator getIterator();
  9. }

4、 ConcreteAggregate

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. /** * 具体聚合 */
  5. public class ConcreteAggregate implements Aggregate { 
  7.     private List<Object> list = new ArrayList<Object>();
  9.     public void add(Object obj) { 
  10.         list.add(obj);
  11.     }
  13.     public void remove(Object obj) { 
  14.         list.remove(obj);
  15.     }
  17.     public Iterator getIterator() { 
  18.         return (new ConcreteIterator(list));
  19.     }
  20. }

5、 Client

  1. public class Client { 
  3.     public static void main(String[] args) { 
  5.         Aggregate ag = new ConcreteAggregate();
  7.         ag.add("中山大学");
  8.         ag.add("华南理工");
  9.         ag.add("韶关学院");
  10.         System.out.print("聚合的内容有：");
  11.         Iterator it = ag.getIterator();
  13.         while (it.hasNext()) { 
  14.             Object ob = it.next();
  15.             System.out.println(ob.toString());
  16.         }        
  18.         System.out.println("\n==========================");
  19.         Object ob = it.first();
  20.         System.out.println("First：" + ob.toString());
  21.     }
  22. }

输出结果：

  1. 聚合的内容有：中山大学    
  2. 华南理工    
  3. 韶关学院
  4. ==========================
  5. First：中山大学

三、大学-学院-专业的示例

3.1、需求

需求是在一个页面中展示大学里学院和其开设的专业。

分析：大学 —> 学院 —> 专业的关系图如下：

在这里插入图片描述

3.2、UML类图

在这里插入图片描述

3.3、代码

1、IteratorForComputerCollege（计算机学院迭代器）

  1. import java.util.Iterator;
  3. /** * 具体迭代器（计算机学院迭代器） */
  4. public class IteratorForComputerCollege implements Iterator { 
  6.     // 这里我们需要Department 是以怎样的方式存放=>数组
  7.     Department[] departments;
  8.     int position = 0; // 遍历的位置
  10.     public IteratorForComputerCollege(Department[] departments) { 
  11.         this.departments = departments;
  12.     }
  14.     // 判断是否还有下一个元素
  15.     @Override
  16.     public boolean hasNext() { 
  17.         if (position >= departments.length || departments[position] == null) { 
  18.             return false;
  19.         } else { 
  21.             return true;
  22.         }
  23.     }
  25.     @Override
  26.     public Object next() { 
  27.         Department department = departments[position];
  28.         position += 1;
  29.         return department;
  30.     }
  32.     // 删除的方法，默认空实现
  33.     public void remove() { 
  35.     }
  36. }

2、IteratorForInfoColleage（信息工程学院迭代器）

  1. import java.util.Iterator;
  2. import java.util.List;
  5. /** * 具体迭代器（信息工程学院迭代器） */
  6. public class IteratorForInfoColleage implements Iterator { 
  8.     List<Department> departmentList; // 信息工程学院是以List方式存放系
  9.     int index = -1;//索引
  12.     public IteratorForInfoColleage(List<Department> departmentList) { 
  13.         this.departmentList = departmentList;
  14.     }
  16.     //判断list中还有没有下一个元素
  17.     @Override
  18.     public boolean hasNext() { 
  19.         if(index >= departmentList.size() - 1) { 
  20.             return false;
  21.         } else { 
  22.             index += 1;
  23.             return true;
  24.         }
  25.     }
  27.     @Override
  28.     public Object next() { 
  29.         return departmentList.get(index);
  30.     }
  32.     //空实现remove
  33.     public void remove() { 
  35.     }
  36. }

3、Department（元素）

  1. public class Department { 
  3.     private String name;
  4.     private String desc;    
  6.     public Department(String name, String desc) { 
  7.         super();
  8.         this.name = name;
  9.         this.desc = desc;
  10.     }
  11.     public String getName() { 
  12.         return name;
  13.     }
  14.     public void setName(String name) { 
  15.         this.name = name;
  16.     }
  17.     public String getDesc() { 
  18.         return desc;
  19.     }
  20.     public void setDesc(String desc) { 
  21.         this.desc = desc;
  22.     }
  23. }

4、Aggregate（聚合接口）

  1. import java.util.Iterator;
  3. /** * 聚合接口 */
  4. public interface Aggregate { 
  6.     public String getName();
  8.     //增加系的方法
  9.     public void addDepartment(String name, String desc);
  11.     //返回一个迭代器,遍历
  12.     public Iterator  createIterator();
  13. }

4、AggregateForComputerCo（计算机学院聚合）

  1. import java.util.Iterator;
  3. /** * 聚合实现类（计算机学院聚合） */
  4. public class AggregateForComputerCo implements Aggregate { 
  6.     Department[] departments;
  7.     int numOfDepartment = 0 ;// 保存当前数组的对象个数 
  9.     public AggregateForComputerCo() { 
  10.         departments = new Department[5];
  11.         addDepartment("Java专业", " Java专业 ");
  12.         addDepartment("PHP专业", " PHP专业 ");
  13.         addDepartment("大数据专业", " 大数据专业 ");        
  14.     }
  17.     @Override
  18.     public String getName() { 
  19.         return "计算机学院";
  20.     }
  22.     @Override
  23.     public void addDepartment(String name, String desc) { 
  24.         Department department = new Department(name, desc);
  25.         departments[numOfDepartment] = department;
  26.         numOfDepartment += 1;
  27.     }
  29.     @Override
  30.     public Iterator createIterator() { 
  31.         return new IteratorForComputerCollege(departments);
  32.     }
  33. }

5、AggregateForInfoCo（信息工程学院聚合实现类）

  1. import java.util.ArrayList;
  2. import java.util.Iterator;
  3. import java.util.List;
  5. /** * 聚合实现类（信息工程学院聚合实现类） */
  6. public class AggregateForInfoCo implements Aggregate { 
  8.     List<Department> departmentList;    
  10.     public AggregateForInfoCo() { 
  11.         departmentList = new ArrayList<Department>();
  12.         addDepartment("信息安全专业", " 信息安全专业 ");
  13.         addDepartment("网络安全专业", " 网络安全专业 ");
  14.         addDepartment("服务器安全专业", " 服务器安全专业 ");
  15.     }
  17.     @Override
  18.     public String getName() { 
  19.         return "信息工程学院";
  20.     }
  22.     @Override
  23.     public void addDepartment(String name, String desc) { 
  24.         Department department = new Department(name, desc);
  25.         departmentList.add(department);
  26.     }
  28.     @Override
  29.     public Iterator createIterator() { 
  30.         return new IteratorForInfoColleage(departmentList);
  31.     }
  32. }

6、OutPutImpl（输出类）

  1. import java.util.Iterator;
  2. import java.util.List;
  4. public class OutPutImpl { 
  6.     //学院集合
  7.     List<Aggregate> collegeList;
  9.     public OutPutImpl(List<Aggregate> collegeList) { 
  10.         this.collegeList = collegeList;
  11.     }
  13.     //遍历所有学院,然后调用printDepartment 输出各个学院的系
  14.     public void printCollege() { 
  16.         //从collegeList 取出所有学院, Java 中的 List 已经实现Iterator
  17.         Iterator<Aggregate> iterator = collegeList.iterator();
  19.         while(iterator.hasNext()) { 
  20.             //取出一个学院
  21.             Aggregate college = iterator.next();
  22.             System.out.println("=== "+college.getName() +"=====" );
  23.             printDepartment(college.createIterator()); //得到对应迭代器
  24.         }
  25.     }
  28.     //输出 学院输出 系
  29.     public void printDepartment(Iterator iterator) { 
  30.         while(iterator.hasNext()) { 
  31.             Department d = (Department)iterator.next();
  32.             System.out.println(d.getName());
  33.         }
  34.     }    
  35. }

7、Client

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class Client { 
  6.     public static void main(String[] args) { 
  7.         // 创建学院
  8.         List<Aggregate> collegeList = new ArrayList<Aggregate>();
  10.         // 计算机学院
  11.         AggregateForComputerCo computerCollege = new AggregateForComputerCo();
  12.         // 信息学院
  13.         AggregateForInfoCo infoCollege = new AggregateForInfoCo();
  15.         collegeList.add(computerCollege);
  16.         collegeList.add(infoCollege);
  18.         // 输出
  19.         OutPutImpl outPutImpl = new OutPutImpl(collegeList);
  20.         outPutImpl.printCollege();
  21.     }
  22. }

输出：

  1. === 计算机学院=====
  2. Java专业
  3. PHP专业
  4. 大数据专业
  5. === 信息工程学院=====
  6. 信息安全专业
  7. 网络安全专业
  8. 服务器安全专业

四、迭代器模式在JDK中应用

4.1、分析 ArrayList 使用迭代器模式

在这里插入图片描述

4.2、分析 LinkedList 使用迭代器模式

4.2.1、LinkedList.java

在这里插入图片描述

4.2.2、AbstractSequentialList.java

AbstractSequentialList 是 LinkedList 的父类。
在这里插入图片描述

4.2.2、AbstractList.java

AbstractList 是 AbstractSequentialList的父类。
在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，31人围观）

还没有评论，来说两句吧...

相关阅读