设计模式——迭代器模式

什么是迭代器模式

迭代器模式是针对集合对象而生的，对于集合对象而言，肯定会涉及到对集合的添加和删除操作，同时也肯定支持遍历集合元素的操作，我们此时可以把遍历操作放在集合对象中，但这样的话，集合对象既承担太多的责任了，面向对象设计原则中有一条就是单一职责原则，所有我们要尽可能地分离这些职责，用不同的类去承担不同的责任，迭代器模式就是用迭代器类来承担遍历集合的职责。

定义：迭代器模式提供了一种方法顺序访问一个聚合对象中的各个元素，而又无需暴露该对象的内部实现，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

迭代器模式的结构

抽象容器角色（Aggregate）：负责提供创建具体迭代器角色的接口，一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等。

具体容器角色（ConcreteAggregate）：就是实现抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkedList,Set接口的哈希列表的实现HashSet等。

抽象迭代器角色（Iterator）：负责定义访问和遍历元素的接口。

具体迭代器角色（ConcreteIterator）：实现迭代器接口，并要记录遍历中的当前位置。

迭代器模式的使用场景

访问一个集合对象的内容而无需暴露它的内部表示
为遍历不同的集合结构提供一个统一的接口

迭代器模式的优缺点

优点：

迭代器模式使得访问一个聚合对象的内容而无需暴露它的内部表示，即迭代抽象。
迭代器模式为遍历不同的集合结构提供了一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作

缺点：

迭代器模式在遍历的同时更改迭代器所在的集合结构会导致出现异常。所以使用foreach语句只能在对集合进行遍历，不能在遍历的同时更改集合中的元素。

迭代器模式的实现

抽象聚合类

public interface CourseAggregate {

    void addCourse(Course course);
    void removeCourse(Course course);

    CourseIterator getCourseIterator();
}

具体聚合类

public class CourseAggregateImpl implements CourseAggregate {

    private List courseList;

    public CourseAggregateImpl() {
        this.courseList = new ArrayList();
    }

    @Override
    public void addCourse(Course course) {
        courseList.add(course);
    }

    @Override
    public void removeCourse(Course course) {
        courseList.remove(course);
    }

    @Override
    public CourseIterator getCourseIterator() {
        return new CourseIteratorImpl(courseList);
    }
}

迭代器抽象类

public interface CourseIterator {
    Course nextCourse();
    boolean isLastCourse();
}

具体迭代器类

public class CourseIteratorImpl implements CourseIterator {

    private List courseList;
    private int position;
    private Course course;

    public CourseIteratorImpl(List courseList) {
        this.courseList = courseList;
    }

    @Override
    public Course nextCourse() {
        System.out.println("返回课程，位置是："+position);
        course = (Course) courseList.get(position);
        position++;
        return course;
    }

    @Override
    public boolean isLastCourse() {
        if(position < courseList.size()){
            return false;
        }
        return true;
    }
}

客户端调用

public class Test {

    public static void main(String[] args) {
        Course course1 = new Course("Spring课程");
        Course course2 = new Course("SpringBoot课程");
        Course course3 = new Course("SpringCloud课程");
        Course course4 = new Course("Netty课程");
        Course course5 = new Course("RocketMQ课程");
        Course course6 = new Course("MySQL课程");

        CourseAggregate courseAggregate = new CourseAggregateImpl();
        courseAggregate.addCourse(course1);
        courseAggregate.addCourse(course2);
        courseAggregate.addCourse(course3);
        courseAggregate.addCourse(course4);
        courseAggregate.addCourse(course5);
        courseAggregate.addCourse(course6);

        System.out.println("------------课程列表------------");
        printCourses(courseAggregate);

        courseAggregate.removeCourse(course4);
        courseAggregate.removeCourse(course5);
        System.out.println("------------删除操作完成之后的课程列表------------");
        printCourses(courseAggregate);
    }

    private static void printCourses(CourseAggregate courseAggregate){
        CourseIterator courseIterator = courseAggregate.getCourseIterator();
        while(!courseIterator.isLastCourse()){
            Course course = courseIterator.nextCourse();
            System.out.println(course.getName());
        }
    }
}

总结

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

参考：
https://www.cnblogs.com/xuwendong/p/9898030.html