第十五章 迭代器模式--看了总结不明白你打我

快速导航

一、迭代器模式介绍

二、代码演示

三、jdk中使用迭代器 模式的地方

四、代码接口有点多，简单总结一下

一、 迭代器模式介绍

定义：提供一种方法，顺序访问一个集合对象中的各个元素，而又不暴露该对象的内部表示。
类型：行为型

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

优点：
分离了集合对象的遍历行为

缺点：
类的个数成对增加

相关设计模式：
迭代器模式和访问者模式

二、代码演示

//课程类
public class Course {
    private String name;
    public Course(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

//课程集合接口
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);
    }
}

//课程 Iterator
public interface CourseIterator {
    Course nextCourse();
    boolean isLastCourse();
}

//课程 Iterator 实现
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("课程1");
        Course course2 = new Course("课程2");
        Course course3 = new Course("课程3");
        Course course4 = new Course("课程4");
        Course course5 = new Course("课程5");
        Course course6 = new Course("课程6");

        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);
    }

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

来看一下类的uml图：

测试结果为：

三、jdk中使用 迭代器模式的地方

1、java.util.Iterator

ArrayList 中的实现：

2、org.apache.ibatis.cursor.defaults.DefaultCursor

四、代码接口有点多，简单总结一下

1、其实迭代器接口，返回的是一个封装的Iterattor对象，调用方拿到Iterator 对象，即可判断是否有下一个元素，进而获取元素。
2、这样写就规避了，常规的接口调用返回 一个具体的 数组，当接口提供方把返回值改为 List 时，调用方也得跟着改 ,生硬。
3、可以借用 迭代器模式，把接口返回值定义为Iterator对象，这样后期的接口集合变动，调用方就不用改了。易用、可扩展。