尚硅谷设计模式学习(17)---[迭代器模式(Iterator Pattern)]

尚硅谷传送门==>B站尚硅谷Java设计模式

❤❤❤感谢尚硅谷❤❤❤

最近开始计划学习一下设计模式了,加油!!!

---

---

情景引入

这次的案例就是之前学习组合模式用到的案例==>

但是这次要使用的是迭代器模式 解决问题.

迭代器模式

提供一种遍历集合元素的统一接口，用统一方法遍历集合元素，无需了解集合对象的底层聚合

适合于集合元素是用不同的方式实现的情况

原理

Iterator ： 迭代器接口，API提供的
在迭代器下右具体的实现类;
由Aggregate负责聚合迭代器;对应的元素类型去使用对应的迭代器实现类.

隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成.

---

接着回到案例;

编写程序展示一个学校院系结构：
要在一个页面中展示出学校的院系组成，
一个学校有多个学院，一个学院有多个系。

专业/系Department

//专业(系);
public class Department {
    //系名;
    private String name;
    //描述;
    private String describe;
    //初始化;
    public Department(String name, String describe) {
        this.name = name;
        this.describe = describe;
    }

    public String getName() {
        return name;
    }

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

    public String getDescribe() {
        return describe;
    }

    public void setDescribe(String describe) {
        this.describe = describe;
    }
}

计算机学院对应的迭代器类ComputerIterator;

//计算机学院的迭代器;
public class ComputerIterator implements Iterator {

    //以数组方式存储--> 系
    Department[] departments;
    //位置;
    int position = 0;
    //初始化;
    public ComputerIterator(Department[] departments) {
        this.departments = departments;
    }
    //判断后面是否还有元素;
    public boolean hasNext() {
        return (!(position>=departments.length||departments[position]==null));
    }
    //指向下一个元素;
    public Object next() {
        Department department = departments[position];
        position+=1;
        return department;
    }
    //删除方法;不实现;
    public void remove() {

    }

}

信息管理学院的对应迭代器类InfoManageIterator

//信息管理学院迭代器;
public class InfoManageIterator implements Iterator {

   //以 List集合的方式存储 -->系;
    List<Department> departmentList;
    //索引位置;
    int index=-1;
    //初始化;
    public InfoManageIterator(List<Department> departmentList) {
        this.departmentList = departmentList;
    }

    //判断后面是否还有元素;
    public boolean hasNext() {
        if(index>=departmentList.size()-1){
            return false;
        }else {
            index+=1;
            return true;
        }
    }
    //指向下一个元素;
    public Object next() {
        return departmentList.get(index);
    }

    //删除方法;
    public void remove() {

    }
}

学院的总接口College

//学院
public interface College {

    //获取学院名字;
    public String getCollName();
    //添加专业(系);
    public void addDepart(String name,String describe);

    //获取迭代器;
    public Iterator getIterator();

}

计算机学院类ComputerCollege

//计算机学院;
public class ComputerCollege implements College{

    //以数组形式存储--系;
    Department[] departments;
    //记录数组的对象数;
    int num=0;

    //初始化;
    public ComputerCollege() {
        departments = new Department[4];
        addDepart("计本","计算机专业");
        addDepart("软工","软件工程专业");
        addDepart("网络","网络工程专业");
        addDepart("统计","数理统计专业");
    }

    public String getCollName() {
        return "这是计算机学院";
    }

    //添加专业;
    public void addDepart(String name, String describe) {
        Department department = new Department(name,describe);
        departments[num] = department;
        num += 1;
    }

    //获取迭代器;--<计算机学院;
    public Iterator getIterator() {
        return new ComputerIterator(departments);
    }
}

信息管理学院类InfoManageCollege

//信息管理学院;
public class InfoManageCollege implements College{
    //以 List集合的方式存储 -->系;
    List<Department> departmentList;

    //初始化;
    public InfoManageCollege() {
        departmentList = new ArrayList<Department>();
        addDepart("信管","信息管理专业");
        addDepart("信计","信息计算专业");
    }

    //返回学院名;
    public String getCollName() {
        return "信息管理学院";
    }

    //添加系;
    public void addDepart(String name, String describe) {
        Department department = new Department(name,describe);
        departmentList.add(department);
    }

    //获取迭代器---<信息管理学院;
    public Iterator getIterator() {
        return new InfoManageIterator(departmentList);
    }
}

封装输出方法的类OutputCollege

//封装方法 ;  输出学院以及 学院的系;
public class OutputCollege {

    List<College> collegeList;

    //获取学院;
    public OutputCollege(List<College> collegeList) {
        this.collegeList = collegeList;
    }

    //输出学院的系;
    public  void  getCollegeAllDepart(){
        Iterator<College> collegeIterator = collegeList.iterator();
        while (collegeIterator.hasNext()){
            //先获取到学院;
            College college = collegeIterator.next();
            System.out.println("学院--->"+college.getCollName());
            //遍历学院下的 系;
            getCollegeDepart(college.getIterator());
        }
    }


    //获取学院中 的系;  仅得到系;
    private void getCollegeDepart(Iterator iterator){
        while (iterator.hasNext()){
            Department next = (Department) iterator.next();
            System.out.println(next.getName()+"->"+next.getDescribe());
        }
    }

}

模拟客户端Client

//模拟客户端;
public class Client {
    public static void main(String[] args) {

        List<College> collegeList = new ArrayList<College>();

        //创建学院;添加到集合中;
        College computerCollege=new ComputerCollege();
        College infoManageCollege=new InfoManageCollege();
        collegeList.add(computerCollege);
        collegeList.add(infoManageCollege);

        //输出遍历;学院下的系;
        OutputCollege outputCollege = new OutputCollege(collegeList);
        outputCollege.getCollegeAllDepart();
    }
}

输出

学院--->这是计算机学院
计本->计算机专业
软工->软件工程专业
网络->网络工程专业
统计->数理统计专业
学院--->信息管理学院
信管->信息管理专业
信计->信息计算专业

---

ArrayList集合中应用的迭代器模式

首先键入ArrayList;它实现了List接口;

OK,键入List接口;
它存在一个抽象方法iterator();用来返回迭代器;

这里List接口就相当于是个聚合接口.ArrayList;就是具体的实现类;

再回到ArrayList,看看它是怎么实现方法iterator()的;

键入返回 的Itr(),发现它是内部类Itr的对象;

具体关系大概为:

---