迭代器模式

迭代器模式（Iterator Pattern）提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。

迭代器模式主要包含以下角色：

• 抽象聚合角色（Aggregate）：定义存储、添加、删除聚合元素以及创建迭代器对象的接口。
• 具体聚合角色（ConcreteAggregate）：实现抽象聚合类,返回一个具体迭代器的实例。
• 抽象迭代器角色（Iterator）：定义访问和遍历聚合元素的接口,通常包含 hasNext()、next() 等方法。
• 具体迭代器角色（Concretelterator）：实现抽象迭代器接口中所定义的方法,完成对聚合对象的遍历,记录遍历的当前位置。

【案例】

定义一个可以存储学生对象的容器对象,将遍历该容器的功能交由迭代器实现

public class IteratorTest {
    public static void main(String[] args) {
        //创建容器对象
        StudentAggregateImpl aggregate = new StudentAggregateImpl();
        //添加元素
        aggregate.addStudent(new Student("张三","0001"));
        aggregate.addStudent(new Student("李四","0002"));
        aggregate.addStudent(new Student("王五","0003"));
        aggregate.addStudent(new Student("赵六","0004"));
        //获取迭代器对象
        StudentIterator iterator = aggregate.getStudentIterator();
        //遍历对象
        while(iterator.hasNext()){
            Student nextStudent = iterator.next();
            System.out.println(nextStudent);
        }
    }
}
//学生类
class Student{
    private String name;
    private String num;

	/* getter and setter 方法 */
    public Student(String name, String num) {
        this.name = name;
        this.num = num;
    }
    public String toString() {
        return "Student{" +"name='" + name + '\'' +", num='" + num + '\'' +'}';
    }
}
//迭代器接口
interface StudentIterator{
    boolean hasNext();
    Student next();
}
//义具体的迭代器类
class StudentIteratorImpl implements StudentIterator{
    private List<Student> list; //存放学生的集合
    private int position = 0;//迭代器指针位置

    public StudentIteratorImpl(List<Student> list) {
        this.list = list;
    }
    public boolean hasNext() {
        return position<list.size();
    }
    public Student next() {
        Student student = list.get(position);
        position++;
        return student;
    }
}
//定义抽象聚合角色
interface StudentAggregate {
    //添加学生
    void addStudent(Student student);
    //删除学生
    void removeStudent(Student student);
    //获取迭代器对象
    StudentIterator getStudentIterator();
}
//具体聚合角色
class StudentAggregateImpl implements StudentAggregate {
    private List<Student> list = new ArrayList<Student>(); // 学生列表
    public void addStudent(Student student) {
        this.list.add(student);
    }
    public void removeStudent(Student student) {
        this.list.remove(student);
    }
    public StudentIterator getStudentIterator() {
        return new StudentIteratorImpl(list);
    }
}

优缺点

• 优点
  1、它支持以不同的方式遍历一个聚合对象,在同一个聚合对象上可以定义多种遍历方式。
  2、迭代器简化了聚合类,由于引入了迭代器,在原有的聚合对象中不需要再自行提供数据遍历等方法,这样可以简化聚合类的设计
  3、在迭代器模式中,由于引入了抽象层,增加新的聚合类和迭代器类都很方便,无须修改原有代码,满足 “开闭原则” 的要求
• 缺点
  增加了类的个数,这在一定程度上增加了系统的复杂性

使用场景

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