该项目源码地址：https://github.com/ggb2312/JavaNotes/tree/master/design-pattern （设计模式相关代码与笔记）

1. 定义

提供一种方法，顺序访问一个集合对象中的各个元素，而又不暴露该对象的内部表示

2. 适用场景

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

3. 类图以及角色

迭代器角色（Iterator）：定义遍历元素所需要的方法，一般来说会有这么三个方法：取得下一个元素的方法next()，判断是否遍历结束的方法hasNext()），移出当前对象的方法remove()
具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代
容器角色(Aggregate)：一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等
具体容器角色（ConcreteAggregate）：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等

4.相关设计模式

迭代器模式和访问者模式

相同：两者都是迭代的访问一个集合对象
不同：访问者模式扩展开放的部分，在作用于对象的操作上。迭代器模式扩展开放的部分，是在集合的种类上。

5.模式实例

有一个课程类：

public class Course {
    private String name;

    public Course(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

}

还有一个CourseAggregate接口，对课程进行处理：

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("Java电商一期");
        Course course2 = new Course("Java电商二期");
        Course course3 = new Course("Java设计模式精讲");
        Course course4 = new Course("Python课程");
        Course course5 = new Course("算法课程");
        Course course6 = new Course("前端课程");
        
        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());
        }
    }
}

测试结果：

测试结果

此时类图：

6. 优缺点

优点：

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

缺点：

类的个数成对增加

7. 扩展-JDK1.7源码以及框架中的迭代器模式

7.1 JDK

java.util.Iterator
java.util.ArrayList中的Itr

7.2 Mybatis

org.apache.ibatis.cursor.defaults.DefaultCursor的cursorIterator

行为型模式——迭代器模式（二）