【设计模式】迭代器模式 ( 简介 | 适用场景 | 优缺点 | 代码示例 )

一、迭代器模式简介

---

迭代器模式 : 提供一种方法 , 顺序访问 集合对象 中的 各个元素 , 而 不暴露 该对象 的内部表示 ;

迭代器模式类型 : 行为型 ;

二、迭代器模式适用场景

---

迭代器模式适用场景 :

• 内容保密 : 访问 集合对象 的内容 , 无需暴露内部表示 ;
• 统一接口 : 为遍历 不同的 集合结构 , 提供统一接口 ;

三、迭代器模式优缺点

---

迭代器模式优点 : 分离 了 集合对象 的 遍历行为 ; 抽象出了 迭代器 负责 集合对象的遍历 , 可以让外部的代码 透明的 访问集合内部的数据 ;

迭代器模式缺点 : 类的个数成对增加 ; 迭代器模式 , 将 存储数据 , 遍历数据 两个职责拆分 ; 如果新添加一个 集合类 , 需要增加该 集合类 对应的 迭代器类 , 类的个数成对增加 , 在一定程度上 , 增加了系统复杂性 ;

四、迭代器模式和访问者模式

---

迭代器模式和访问者模式 : 两个模式都是 迭代地 访问集合对象中的元素 ,

• 访问者模式 : 访问者模式 中 , 扩展开放的部分 , 作用于对象的操作上 ;
• 迭代器模式 : 迭代器模式 中 , 扩展开放的部分 , 是在对象的种类上 ;

迭代器模式 , 应用广泛 , 但是基本都使用 JDK 中提供的迭代器 , 不需要自己实现 ;

五、迭代器模式代码示例

---

业务场景 : 使用迭代器模式 , 管理多个学生的信息 ;

1、迭代器接口

package iterator;

public interface StudentIterator {
    /**
     * 获取下一个学生对象
     * @return
     */
    Student nextStudent();

    /**
     * 是否是最后一个
     * @return
     */
    boolean isLast();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、迭代器实现

package iterator;

import java.util.ArrayList;

public class StudentIteratorImpl implements StudentIterator{
    /**
     * 学生集合, 通过构造函数注入
     */
    private ArrayList<Student> list;

    /**
     * 当前处理的集合索引
     */
    private int position;

    /**
     * 当前处理的学生对象
     */
    private Student student;

    public StudentIteratorImpl(ArrayList<Student> list) {
        this.list = list;
    }

    @Override
    public Student nextStudent() {
        System.out.println("返回 " + position + " 位置的学生对象 : " + student);
        student = list.get(position);
        position++;
        return student;
    }

    @Override
    public boolean isLast() {
        return position < list.size() ? false : 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
34
35
36
37

3、集合元素实例类

=package iterator;

public class Student {
    String name;

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

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4、集合管理接口

package iterator;

/**
 * 集合的管理类
 */
public interface StudentAggregate {
    /**
     * 增加学生
     * @param student
     */
    void addStudent(Student student);

    /**
     * 删除学生
     */
    void removeStudent(Student student);

    /**
     * 获取学生集合的迭代器
     * @return
     */
    StudentIterator getStudentIterator();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5、集合管理实现类

package iterator;

import java.util.ArrayList;

/**
 * 维护集合
 */
public class StudentAggregateImpl implements StudentAggregate{
    /**
     * 学生集合
     */
    private ArrayList<Student> list;

    public StudentAggregateImpl() {
        this.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);
    }
}
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

6、测试类

package iterator;

public class Main {
    public static void main(String[] args) {
        // 创建 3 个学生对象
        Student tom = new Student("Tom");
        Student jerry = new Student("Jerry");
        Student trump = new Student("Trump");

        // 构造学生对象集合
        StudentAggregate studentAggregate = new StudentAggregateImpl();
        studentAggregate.addStudent(tom);
        studentAggregate.addStudent(jerry);
        studentAggregate.addStudent(trump);

        // 获取学生对象的迭代器
        StudentIterator studentIterator = studentAggregate.getStudentIterator();
        // 判断是否是最后一个对象 , 如果不是 , 获取下一个对象 , 并打印
        while (!studentIterator.isLast()) {
            Student student = studentIterator.nextStudent();
            System.out.println(student);
        }

        // 删除一个对象
        studentAggregate.removeStudent(trump);
        System.out.println("删除 Trump" );

        studentIterator = studentAggregate.getStudentIterator();
        // 判断是否是最后一个对象 , 如果不是 , 获取下一个对象 , 并打印
        while (!studentIterator.isLast()) {
            Student student = studentIterator.nextStudent();
            System.out.println(student);
        }
    }
}
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
34
35

执行结果 :

返回 0 位置的学生对象 : null
Student{name='Tom'}
返回 1 位置的学生对象 : Student{name='Tom'}
Student{name='Jerry'}
返回 2 位置的学生对象 : Student{name='Jerry'}
Student{name='Trump'}
删除 Trump
返回 0 位置的学生对象 : null
Student{name='Tom'}
返回 1 位置的学生对象 : Student{name='Tom'}
Student{name='Jerry'}
1
2
3
4
5
6
7
8
9
10
11