迭代器设计模式的思想和案例实现【行为型】

迭代器模式是一种行为型设计模式，它允许通过对集合对象进行迭代来访问集合中的元素，而不需要暴露集合内部的结构。

在迭代器模式中，我们定义了一个迭代器接口，该接口封装了遍历集合元素的行为。集合对象实现该接口，并返回一个迭代器对象，该迭代器对象可以通过调用一系列方法来遍历集合中的元素。

例如：我们向定义了一个学生容器，可以向容器中添加学生、移除学生和遍历学生。就可以使用迭代器模式了。

在迭代器模式中主要包括 4 中不同的角色：

1. 抽象迭代器：一般情况下，在迭代器中主要有两个抽象方法，判断是否存在下一个元素和获取当前元素

2. 具体迭代器：提供抽象迭代器中抽象方法的具体实现

3. 抽象聚合角色: 相当于就是容器对象，一般提供向容器中添加元素、移除元素和获取容器的迭代器对象

4. 具体聚合角色：提供抽象容器对象中的额抽象方法的具体实现

代码实现：

1、创建抽象迭代器和想要迭代遍历的对象【学生】

/**
 * 抽象迭代器
 **/
public interface StudentIterator {
​
    boolean hasNeNext();
​
    Student next();
}
​
​
public class Student {
​
    private String id;
    private String name;
​
    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

2、创建具体迭代器角色

/**
 * 具体迭代器角色
 **/
public class StudentIteratorImpl implements StudentIterator{
​
    private List<Student> list;
    private int index = 0;
​
    /**
     * 构造器
     **/
    public StudentIteratorImpl(List<Student> list) {
        this.list = list;
    }
​
    @Override
    public boolean hasNeNext() {
        return this.index < this.list.size();
    }
​
    /**
     * 返回下一个角色
     **/
    @Override
    public Student next() {
        Student student = list.get(index);
        index++;
        return student;
    }
}

3、创建抽象聚合角色

/**
 * 定义一个学生抽象容器，包括添加、删除和获取学生的迭代器对象
 **/
public interface StudentAggregate {
​
    void addStudent(Student student);
​
    void removeStudent(Student student);
​
    StudentIterator getStudentIterator();
}

4、创建具体聚合角色

public class StudentAggregateImpl implements StudentAggregate{
​
    private List<Student> list = new ArrayList<>();
​
    @Override
    public void addStudent(Student student) {
        this.list.add(student);
    }
​
    @Override
    public void removeStudent(Student student) {
        this.list.remove(student);
    }
​
    @Override
    public StudentIterator getStudentIterator() {
        return new StudentIteratorImpl(this.list);
    }
}

5、测试

public static void main(String[] args) {
    Student student1 = new Student("001", "小美");
    Student student2 = new Student("002", "小娜");
    //向学生容器中添加两个学生
    StudentAggregate aggregate = new StudentAggregateImpl();
    aggregate.addStudent(student1);
    aggregate.addStudent(student2);
    //获取容器对象的迭代器，这里使用多态
    StudentIterator iterator = aggregate.getStudentIterator();
    //循环遍历迭代器中的对象，打印输出
    while (iterator.hasNeNext()){
        Student next = iterator.next();
        System.out.println("next = " + next);
    }
}
​
​
//测试结果
next = Student{id='001', name='小美'}
next = Student{id='002', name='小娜'}
​
Process finished with exit code 0

优点：

1. 同一个容器对象可以提供多种不同的遍历方式。在迭代器模式中只需要提供一个不同的迭代器就可以实现不同的遍历。这里我们只需要为 StudentIterator 提供一个新的实现类，在重写抽象方法时修改 hasNext() 和 next() 方法即可。

2. 简化了容器类，由于引入了迭代器，原有的容器中不需要提供具体的遍历方法了。

3. 待迭代器模式中，因为引入了抽象层，所以添加新的容器和迭代器就变得和容易。完全符合开闭原则。

缺点：增加了类的个数，一定程度上增加了系统的复杂性。