设计模式之迭代器模式笔记

说明

记录下学习设计模式-迭代器模式的写法。JDK使用版本为1.8版本。

Iterator(迭代器)

意图:提供一种方法顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示。
结构:

其中：

• Iterator(选代器)定义访问和遍历元素的接口。
• Concretelterator(具体迭代器)实现选代器接口:对该聚合遍历时跟踪当前位置。
• Aggregate (聚合)定义创建相应选代器对象的接口。
• ConcreteAggregate(具体聚合)实现创建相应选代器的接口,该操作返回 Concretelterator的一个适当的实例。

适用性:

• 访问一个聚合对象的内容而无须暴露它的内部表示。
• 支持对聚合对象的多种遍历。
• 为遍历不同的聚合结构提供一个统一的接口。

目录

迭代器模式示例类图

以该UML类图实现迭代器模式示例。

学生类

package com.example.deesign_patterns.iterator;

//学生类
public class Student {

    private String name;
    private String number;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", number='" + number + '\'' +
                '}';
    }
}

抽象迭代器角色接口

package com.example.deesign_patterns.iterator;

//抽象迭代器角色接口
public interface StudentIterator {

    //判断是否还有元素
    boolean hasNext();

    //获取下一个元素
    Student next();
}

具体迭代器角色类

package com.example.deesign_patterns.iterator;

import java.util.List;

//具体迭代器角色类
public class StudentIteratorImpl implements StudentIterator{

    private List<Student> list;
    private int position=0;//用来记录遍历时的位置

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

    @Override
    public boolean hasNext() {
        return position< list.size();
    }

    @Override
    public Student next() {
        //从集合中获取指定位置的元素
        Student currentStudent = list.get(position);
        position++;
        return currentStudent;
    }
}

抽象聚合角色接口

package com.example.deesign_patterns.iterator;

//抽象聚合角色接口
public interface StudentAggregate {

    //添加学生功能
    void addStudent(Student stu);

    //删除学生功能
    void removeStudent(Student stu);

    //获取迭代器对象功能
    StudentIterator getStudentIterator();
}

具体聚合角色类

package com.example.deesign_patterns.iterator;

import java.util.ArrayList;
import java.util.List;

//具体聚合角色类
public class StudentAggregateImpl implements StudentAggregate{

    private List<Student> list=new ArrayList<Student>();

    @Override
    public void addStudent(Student stu) {
        list.add(stu);
    }

    @Override
    public void removeStudent(Student stu) {
        list.remove(stu);
    }

    //获取迭代器对象
    @Override
    public StudentIterator getStudentIterator() {
        return new StudentIteratorImpl(list);
    }
}

测试类

package com.example.deesign_patterns.iterator;

//测试类
public class Client {

    public static void main(String[] args) {
        //创建聚合对象
        StudentAggregateImpl aggregate=new StudentAggregateImpl();
        //添加元素
        aggregate.addStudent(new Student("张三","001"));
        aggregate.addStudent(new Student("李四","002"));
        aggregate.addStudent(new Student("王五","003"));
        aggregate.addStudent(new Student("赵六","004"));
        //遍历聚合对象
        //获取迭代器对象
        StudentIterator iterator=aggregate.getStudentIterator();
        //遍历
        while (iterator.hasNext()){
            //获取元素
            Student student=iterator.next();
            System.out.println(student.toString());
        }
    }
}

好处：

• 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的送代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
• 选代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
• 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。

缺点:

• 增加了类的个数，这在一定程度上增加了系统的复杂性。