迭代器模式

1 概念

1 定义

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

类型：行为型

2 应用场景

  • 访问一个集合的内容，而不暴露该对象的内部展示
  • 为遍历不同的集合结构提供一个统一的接口

平时我们不太会自己写，因为已经有很多工具类写好了

3 优缺点

优点：

  • 分离了集合对象的存储和遍历行为，由迭代器进行遍历

缺点：

  • 类的个数成对增加，需要新增迭代器类

2 代码实现

场景： 遍历课程列表

1
2
3
4
5
@Data
@AllArgsConstructor
public class Course {
    private String name;
}
1
2
3
4
public interface CourseAggregate {
    void addCourse(Course course);
    CourseIterator getIterator();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 CourseIterator getIterator() {
        return new CourseIteratorImpl(courseList);
    }
}
1
2
3
4
public interface CourseIterator {
    Course nextCourse();
    boolean hasNext();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class CourseIteratorImpl implements CourseIterator {

    private final List<Course> courseList;
    private int position;
    private Course course;
    public CourseIteratorImpl(List<Course> courseList){
        this.courseList=courseList;
    }

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

    @Override
    public boolean hasNext(){
        if(position< courseList.size()){
            return false;
        }
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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);
    }


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

输出：

返回课程,位置是: 0
Java电商一期
返回课程,位置是: 1
Java电商二期
返回课程,位置是: 2
Java设计模式精讲
返回课程,位置是: 3
Python课程
返回课程,位置是: 4
算法课程
返回课程,位置是: 5
前端课程

设计模式
迭代器模式
http://example.com/迭代器模式/
作者
Panyurou
发布于
2023年10月4日
许可协议