设计模式之迭代器（iterator）模式
需求： 假设，有一个教室类，里面包含了一堆学生，现在要遍历教室里的学生，怎么操作？
1.1 不使用迭代器模式的方式
public class WithoutIteratorPatternDemo {
public static void main(String[] args) {
Student student1 = new Student("小李");
Student student2 = new Student("小吴");
Student[] students = new Student[2];
students[0] = student1;
students[1] = student2;
Classroom classroom = new Classroom();
classroom.setStudents(students);
Student[] studentsResults = classroom.getStudents();
for (Student student : studentsResults) {
System.out.println(student);
}
}
/**
* 学生类
*/
public static class Student{
public String name;
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
/**
* 教室类
*/
public static class Classroom {
private Student[] students;
public Student[] getStudents() {
return students;
}
public void setStudents(Student[] students) {
this.students = students;
}
}
}
1.2 不使用迭代器模式的方式 -- 集合中数据格式变了
public class WithoutIteratorPatternDemo2 {
public static void main(String[] args) {
Student student1 = new Student("小李");
Student student2 = new Student("小吴");
Map<String, Student> students = new HashMap<String, Student>();
students.put(student1.getName(), student1);
students.put(student2.getName(), student2);
Classroom classroom = new Classroom();
classroom.setStudents(students);
Map<String, Student> studentsResults = classroom.getStudents();
for (Student studentsResult : studentsResults.values()) {
System.out.println(studentsResult);
}
}
/**
* 学生类
*/
public static class Student{
public String name;
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
/**
* 教室类 -- 格式发生改变
*/
public static class Classroom {
private Map<String, Student> students;
public void setStudents(Map<String, Student> students) {
this.students = students;
}
public Map<String, Student> getStudents() {
return students;
}
}
}
不使用设计模式的缺点：
如果不使用任何设计模式，直接去遍历一个类中的集合，一旦这个类中对集合的使用改变了，比如上面的例子： 从数组 --> map，或者其他的改变，那么迭代的代码，就需要发生改动。
如果代码和逻辑比较复杂，集合类的实现和遍历代码的实现由不同的人开发或不同的模块使用，就会有比较大的影响，可维护性和可扩展性比较差。
1.3 使用迭代器模式实现
package com.lucky.pattern.iterator;
/**
* @author: LIJY
* @Description: iterator (迭代器)模式 -- 用迭代器模式实现
* @Date: 2021/10/1 17:03
*/
public class IteratorDesignPatternDemo {
public static void main(String[] args) {
Student student1 = new Student("小李");
Student student2 = new Student("小吴");
Classroom classroom = new Classroom(2);
classroom.addStudent(student1);
classroom.addStudent(student2);
Iterator iterator = classroom.iterator();
while (iterator.hasNext()){
Student student = (Student) iterator.next();
System.out.println(student);
}
}
/**
* 定义一个迭代器
*/
public interface Iterator {
public abstract boolean hasNext();
public abstract Object next();
}
/**
* 定义一个集合类
*/
public interface Aggregate {
public abstract Iterator iterator();
}
/**
* 学生类
*/
public static class Student{
public String name;
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
/**
* 教室类
*/
public static class Classroom implements Aggregate {
private Student[] students;
// last 相当于数组的长度
private int last = 0;
public Classroom(int size) {
this.students = new Student[size];
}
public Student getStudent(int index) {
return students[index];
}
public void addStudent(Student student) {
this.students[last] = student;
last ++;
}
public int getLength() {
return last;
}
/**
* 返回一个教室迭代器，其中封装了教室自己，让迭代器可以获取教室中的数据。
* @return
*/
public Iterator iterator() {
return new ClassroomIterator(this);
}
}
/**
* 教室迭代器
*/
public static class ClassroomIterator implements Iterator {
private Classroom classroom;
private int index;
public ClassroomIterator(Classroom classroom) {
this.classroom = classroom;
this.index = 0;
}
/**
* 判断数组是否还有下一个元素
* 假设此时 index = 0，classroom 的 length = 2， 那么还有下一个元素，数组没有遍历完。
* 假设此时 index = 2，classroom 的 length = 2， 那么就没有下一个元素。 classroom 可以遍历的数组的 offest 只能是 0 和 1
* @return
*/
public boolean hasNext() {
if(index < classroom.getLength()) {
return true;
} else {
return false;
}
}
/**
* 获取数组集合当前的元素。
* 从数组中获取当前这个学生，同时将 index 往后移动一位
* 比如 一开始 index 是0，数组长度是 2
* 此时遍历获取第一个学生之后，返回数组的 0 元素，然后将 index 变成 1。
* @return
*/
public Object next() {
Student student = classroom.getStudent(index);
index++;
return student;
}
}
}
1.4 使用迭代器模式实现 -- 集合中数据变成 List
package com.lucky.pattern.iterator;
import java.util.ArrayList;
import java.util.List;
/**
* @author: LIJY
* @Description: iterator (迭代器)模式 -- 用迭代器模式实现
* @Date: 2021/10/1 17:03
*/
public class IteratorDesignPatternDemo2 {
public static void main(String[] args) {
Student student1 = new Student("小李");
Student student2 = new Student("小吴");
Classroom classroom = new Classroom(2);
classroom.addStudent(student1);
classroom.addStudent(student2);
Iterator iterator = classroom.iterator();
while (iterator.hasNext()){
Student student = (Student) iterator.next();
System.out.println(student);
}
}
/**
* 定义一个迭代器
*/
public interface Iterator {
public abstract boolean hasNext();
public abstract Object next();
}
/**
* 定义一个集合类
*/
public interface Aggregate {
public abstract Iterator iterator();
}
/**
* 学生类
*/
public static class Student{
public String name;
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
/**
* 教室类
*/
public static class Classroom implements Aggregate {
// private Student[] students;
private List<Student> students;
/**
* last 相当于数组的长度
*/
private int last = 0;
public Classroom(int size) {
// this.students = new Student[size];
this.students = new ArrayList<Student>(2);
}
public Student getStudent(int index) {
// return students[index];
return students.get(index);
}
public void addStudent(Student student) {
// this.students[last] = student;
this.students.add(student);
last ++;
}
public int getLength() {
return last;
}
/**
* 返回一个教室迭代器，其中封装了教室自己，让迭代器可以获取教室中的数据。
* @return
*/
public Iterator iterator() {
return new ClassroomIterator(this);
}
}
/**
* 教室迭代器
*/
public static class ClassroomIterator implements Iterator {
private Classroom classroom;
private int index;
public ClassroomIterator(Classroom classroom) {
this.classroom = classroom;
this.index = 0;
}
/**
* 判断数组是否还有下一个元素
* 假设此时 index = 0，classroom 的 length = 2， 那么还有下一个元素，数组没有遍历完。
* 假设此时 index = 2，classroom 的 length = 2， 那么就没有下一个元素。 classroom 可以遍历的数组的 offest 只能是 0 和 1
* @return
*/
public boolean hasNext() {
if(index < classroom.getLength()) {
return true;
} else {
return false;
}
}
/**
* 获取数组集合当前的元素。
* 从数组中获取当前这个学生，同时将 index 往后移动一位
* 比如 一开始 index 是0，数组长度是 2
* 此时遍历获取第一个学生之后，返回数组的 0 元素，然后将 index 变成 1。
* @return
*/
public Object next() {
Student student = classroom.getStudent(index);
index++;
return student;
}
}
}
1.5 使用 JDK 封装好的 Iterator
package com.lucky.pattern.iterator;
import java.util.ArrayList;
import java.util.List;
/**
* @author: LIJY
* @Description: iterator (迭代器)模式 -- 用迭代器模式实现
* @Date: 2021/10/1 17:03
*/
public class IteratorDesignPatternDemo2 {
public static void main(String[] args) {
Student student1 = new Student("小李");
Student student2 = new Student("小吴");
Classroom classroom = new Classroom(2);
classroom.addStudent(student1);
classroom.addStudent(student2);
// Iterator iterator = classroom.iterator();
java.util.Iterator iterator = classroom.iterator();
while (iterator.hasNext()){
Student student = (Student) iterator.next();
System.out.println(student);
}
}
/**
* 定义一个迭代器
*/
public interface Iterator {
public abstract boolean hasNext();
public abstract Object next();
}
/**
* 定义一个集合类
*/
public interface Aggregate {
// public abstract Iterator iterator();
public abstract java.util.Iterator iterator();
}
/**
* 学生类
*/
public static class Student{
public String name;
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
/**
* 教室类
*/
public static class Classroom implements Aggregate {
// private Student[] students;
private List<Student> students;
/**
* last 相当于数组的长度
*/
private int last = 0;
public Classroom(int size) {
// this.students = new Student[size];
this.students = new ArrayList<Student>(2);
}
public Student getStudent(int index) {
// return students[index];
return students.get(index);
}
public void addStudent(Student student) {
// this.students[last] = student;
this.students.add(student);
last ++;
}
public int getLength() {
return last;
}
/**
* 返回一个教室迭代器，其中封装了教室自己，让迭代器可以获取教室中的数据。
* @return
*/
// public Iterator iterator() {
// return new ClassroomIterator(this);
// }
public java.util.Iterator iterator() {
return students.iterator();
}
}
/**
* 教室迭代器
*/
public static class ClassroomIterator implements Iterator {
private Classroom classroom;
private int index;
public ClassroomIterator(Classroom classroom) {
this.classroom = classroom;
this.index = 0;
}
/**
* 判断数组是否还有下一个元素
* 假设此时 index = 0，classroom 的 length = 2， 那么还有下一个元素，数组没有遍历完。
* 假设此时 index = 2，classroom 的 length = 2， 那么就没有下一个元素。 classroom 可以遍历的数组的 offest 只能是 0 和 1
* @return
*/
public boolean hasNext() {
if(index < classroom.getLength()) {
return true;
} else {
return false;
}
}
/**
* 获取数组集合当前的元素。
* 从数组中获取当前这个学生，同时将 index 往后移动一位
* 比如 一开始 index 是0，数组长度是 2
* 此时遍历获取第一个学生之后，返回数组的 0 元素，然后将 index 变成 1。
* @return
*/
public Object next() {
Student student = classroom.getStudent(index);
index++;
return student;
}
}
}
总结
面向Iterator接口编程，无论底层的数据结构和迭代算法如何变化，调用者都不用修改代码。
其实一般很少自己写这个 iterator 模式的，一般都是在集合编程中使用，尤其是如果要对集合元素遍历过程中做插入删除操作，那就用iterator，JDK本身已经封装好了iterator模式，如果要对某个类中的集合进行遍历，由那个集合类返回一个iterator回来，我们统一面向iterator迭代器接口来编程遍历，提高系统整体的可维护性，可扩展性。
