设计模式之迭代器模式

什么是迭代器模式

        迭代器模式（Iterator pattern）是一种对象行为型设计模式，它提供了一种方法来顺序访问聚合对象中的元素，而又不暴露该对象的内部表示，同时也可以将迭代逻辑与聚合对象的实现分离，增强了代码的可维护性和可扩展性。

        迭代器模式的特征如下：

• 迭代器模式允许一个聚合对象公开它的每一个元素，而又不暴露其内部表示，即它提供了一种方法来遍历聚合对象中的每一个元素，而不需要了解该对象的内部结构或实现。
• 迭代器模式的主要目的是将迭代逻辑封装在迭代器对象中，而不是将该逻辑嵌入到聚合对象中。这样可以将迭代逻辑与聚合对象的实现分离，使得它们可以独立地改变和扩展。
• 迭代器模式是通过定义一个迭代器接口来实现的。该接口提供了访问和遍历聚合对象的元素的方法。聚合对象则需要实现一个能够创建相应迭代器的接口。

迭代器模式的核心角色

1. 迭代器接口（Iterator）：定义了访问和遍历集合元素的方法，为使用者提供了一种方便的方式来遍历集合中的元素，而不必关心集合的实现细节，如：是否能够继续遍历下一个元素、取出下一个元素等。
2. 具体迭代器（ConcreteIterator）：持有一个具体的集合，并且实现了迭代器接口，实际负责按照特定的顺序遍历集合中的元素，并将遍历结果反馈给使用者。
3. 集合接口（Aggregate）：定义了创建迭代器的抽象方法，隐藏了具体集合的表示和实现，具体的表示和实现由具体集合类来负责实现；
4. 具体集合（ConcreteAggregate）：该类实现了集合接口，创建出具体的迭代器对象，供使用者通过迭代器来访问和遍历集合元素。当然，作为具体集合，需要提供具体的添加、移除、查询集合长度的具体方法；

迭代器模式如何实现

需求描述

        回想在上大学的时候，老师在教学活动中都会拥有一个学生的花名册，上面有学生的姓名、学号等信息，每次上课前都要先按照名册上记录的顺序逐一点名，如果帮老师写一个自动点名的程序，那么这个时候使用迭代器模式绝对是非常不错的一个选择。那么具体怎么实现呢？

实现方法

1、定义一个迭代器接口，即名册迭代器接口，主要有两个抽象方法：判断是否下一个元素可以遍历、遍历取出下一个元素；

/*** 名删除迭代器抽象接口* @param <T>*/
public interface RosterInterator<T> {/*** 是否有下一个元素* @return*/boolean hasNext();/*** 取出下一个元素* @return*/T next();
}

2、定义一个集合接口：抽象名册接口，定义一个抽象方法：获取名册迭代器；

/*** 名册*/
public interface Roster<T> {/*** 获取迭代器* @return*/RosterInterator<T> getInterator();
}

3、定义具体的集合，即具体的学生名册类，具体的学生名册类除了正常可以往学生名册上添加、移除学生，查询学生名册上人员数量方法外，还要实现抽象名册接口的获取名册迭代器的方法，在方法中创建具体的迭代器对象；

/*** 学生类*/
@Data
public class Student {private String stuNo;private String name;public Student(String stuNo, String name) {this.stuNo = stuNo;this.name = name;}
}

/*** 学生名册*/
@Data
public class StudentRoster implements Roster<Student>{/*** 学生对象集合*/private List<Student> list=new ArrayList<>();/*** 添加学生* @param student*/public void add(Student student){this.list.add(student);}/*** 移除学生* @param student*/public void remove(Student student){this.list.remove(student);}/*** 学生名册学生对象数量* @return*/public Integer size(){return this.list.size();}@Overridepublic RosterInterator<Student> getInterator() {return new StudentRosterInterator(this);}
}

4、定义集合迭代器实现，即具体的学生名册迭代器，具体的学生迭代器会持有具体的学生名册，并实现名册迭代器定义的两个抽象方法，即具体的判断是否有下一个元素可以遍历、遍历取出下一个元素；

/*** 学生名册迭代器*/
@Data
public class StudentRosterInterator implements RosterInterator<Student>{/*** 学生名册*/private StudentRoster roster;/*** 索引位置*/private Integer index=0;public StudentRosterInterator(StudentRoster roster) {this.roster = roster;}@Overridepublic boolean hasNext() {return this.roster.size() > index;}@Overridepublic Student next() {Student student = this.roster.getList().get(index);index++;return student;}
}

5、编写客户端类

public class StudentClient {public static void main(String[] args) {StudentRoster studentRoster=new StudentRoster();Student stu1 = new Student("s001", "小明");Student stu2 = new Student("s002", "小红");Student stu3 = new Student("s003", "小刚");studentRoster.add(stu1);studentRoster.add(stu2);studentRoster.add(stu3);RosterInterator<Student> rosterInterator=new StudentRosterInterator(studentRoster);while (rosterInterator.hasNext()) {Student student = rosterInterator.next();System.out.println(student.getStuNo()+":"+student.getName());}}
}

如何扩展

老师上课的时候会根据学生画名册点名，那么学校领导在给老师们开会的时候，有没有可能也会点一个名，看年哪位老师没有到？当然会。假如也要帮校长实现一个对老师们的点名程序，应该怎么在原先的基础上扩展呢？其实很简单，保持原有的抽象名册迭代器接口、抽象名册接口不变，再分别实现老师画名册、老师画名册迭代器就可。而且这一过程完全符合开闭原则，不会对原来的程序造成任何影响，这就是设计模式的魅力。

/*** 老师类*/
@Data
public class Teacher {private String teacNo;private String name;public Teacher(String teacNo, String name) {this.teacNo = teacNo;this.name = name;}
}

/*** 老师名册*/
@Data
public class TeacherRoster implements Roster<Teacher>{/*** 老师对象集合*/private List<Teacher> list=new ArrayList<>();/*** 添加老师* @param teacher*/public void add(Teacher teacher){this.list.add(teacher);}/*** 移除老师* @param teacher*/public void remove(Teacher teacher){this.list.remove(teacher);}/*** 老师名册中对象数量* @return*/public Integer size(){return this.list.size();}@Overridepublic RosterInterator<Teacher> getInterator() {return new TeacherRosterInterator(this) ;}
}

/*** 老师名册迭代器*/
@Data
public class TeacherRosterInterator implements RosterInterator<Teacher> {private TeacherRoster teacherRoster;private Integer index = 0;public TeacherRosterInterator(TeacherRoster teacherRoster) {this.teacherRoster = teacherRoster;}@Overridepublic boolean hasNext() {return this.teacherRoster.size() > index;}@Overridepublic Teacher next() {Teacher teacher = this.teacherRoster.getList().get(index);index++;return teacher;}
}

public class TeacherClent {public static void main(String[] args) {TeacherRoster teacherRoster=new TeacherRoster();Teacher t1 = new Teacher("t001", "王老师");Teacher t2 = new Teacher("t002", "李老师");Teacher t3 = new Teacher("t003", "张老师");teacherRoster.add(t1);teacherRoster.add(t2);teacherRoster.add(t3);RosterInterator<Teacher> rosterInterator=new TeacherRosterInterator(teacherRoster);while (rosterInterator.hasNext()) {Teacher teacher = rosterInterator.next();System.out.println(teacher.getTeacNo()+":"+teacher.getName());}}
}

迭代器模式的适用场景

        业务场景具有下面的特征就可以使用迭代器模式：

• 需要遍历集合对象中的元素，而不暴露该对象的内部表示的场景。通过使用迭代器模式，可以在不暴露集合对象内部结构的情况下，顺序访问集合对象中的各个元素。
• 需要为遍历不同的集合结构提供统一接口的场景。迭代器模式可以提供一种统一的接口，用于遍历不同的集合结构，从而使得代码更加灵活和可扩展。

有没有比较具体的业务场景示例呢？当然有，比如：

1. 在物流系统中，可以使用迭代器模式来遍历物品。例如，在传送带上，不管传送的是什么物品，都被打包成一个一个的箱子并且有一个统一的二维码。这样我们不需要关心箱子里是什么物品，只需要一个一个检查发送的目的地即可。
2. 在图片播放器中，可以使用迭代器模式来遍历图片。这样可以在不暴露图片内部结构的情况下，顺序访问图片中的各个元素。
3. 图书馆管理系统：在图书馆中，需要对书籍进行遍历，可以使用迭代器模式来处理。通过定义一个统一的迭代器接口，不同的数据结构（如数组、链表等）都可以使用相同的迭代器接口来遍历书籍，同时保持内部实现的封装。
4. 电商网站：在电商网站中，通常需要对商品进行展示和遍历。使用迭代器模式可以实现对商品的顺序访问，而不暴露商品内部表示。
5. 金融系统：在金融系统中，需要对账户、交易等进行处理。使用迭代器模式可以实现对账户或交易的顺序访问，而不暴露其内部表示。
6. 音乐播放器：在音乐播放器中，需要遍历音乐库中的歌曲。使用迭代器模式可以实现对歌曲的顺序访问，而不暴露歌曲内部表示。

总结

优点

1. 分离集合与迭代逻辑：迭代器模式将集合对象与遍历逻辑分离，使得它们可以独立变化。集合对象只需要实现迭代器接口，而客户端只需要通过迭代器进行遍历操作，从而实现了解耦和模块化。
2. 统一遍历接口：迭代器模式定义了一组统一的遍历接口，使得客户端可以以相同的方式对待不同类型的集合对象。无论是数组、链表、树状结构还是其他自定义集合，只要它们提供了符合迭代器接口的迭代器对象，就可以使用迭代器模式进行遍历，提高了代码的灵活性和可复用性。
3. 简化客户端代码：使用迭代器模式可以简化客户端代码，减少了对集合内部结构的直接操作，只需要通过迭代器对象进行遍历操作。

缺点

1. 可能增加代码复杂度：使用迭代器模式可能会增加一些额外的代码复杂度，例如需要定义迭代器接口、具体迭代器实现类等。
2. 限制集合对象的类型：迭代器模式通常只适用于集合类型的聚合对象，不能很好地处理其他类型的聚合对象，例如树形结构、图形结构等。
3. 可能增加内存开销：使用迭代器模式可能会增加一些额外的内存开销，例如需要创建迭代器对象等。

        总之，迭代器模式在许多业务场景中都有应用，可以实现对集合对象的顺序访问，而不暴露其内部表示，可以使得代码更加清晰、简洁、易于维护。