迭代器模式

迭代器模式

起男 1,041 2021-06-15

迭代器模式

需求

在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系

基本介绍

  • 迭代器模式是常用的设计模式，属于行为型模式
  • 如果我们的集合元素是用不同的方式实现的，有数组，还有集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候，就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决
  • 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露内部的结构

实现

系

@Data
public class Department{
    private String name;
    private String desc;
}

迭代器实现（迭代器接口有jdk提供），遍历数据

//计算机学院迭代器
public class ComputerCollegeIterator implements Iterator{
    
    //Department以数组的形式存放
    private Department[] departments;
    //遍历的位置
    private int position = 0;
    
    public ComputerCollegeIterator(Department[] departments){
        this.departments = departments;
    }
    
    //判断是否有下一个元素
    @Override
    public boolean hasNext(){
        if(position >= departments.length || departments[position] == null){
            return false;
        }else{
            return true;
        }
    }
    //获取元素
    @Oberride
    public Object next(){
        Department department = departments[position];
        position++;
        return department
    }
}

//信息工程学院迭代器
public class InfoColleageIterator implements Iterator{
    
    //Department以集合的形式存放
    private List<Department> departmentList;
    //索引
    private int index = -1;
    
    public InfoColleageIterator(List<Department> departmentList){
        this.departmentList = departmentList;
    }
    
    //判断是否有下一个元素
    @Override
    public boolean hasNext(){
        if(index >= departmentList.size() - 1){
            return false;
        }else{
            index++;
            return true;
        }
    }
    //获取元素
    @Oberride
    public Object next(){
        return departments.get(index);
    }
}

学院抽象，存放数据

public interface College{
    //学院名称
    public String getName();
    
    //增加系
    public void addDepartment(String name,String desc);
    
    //返回一个迭代器
    public Iterator createIterator();
}

学院实现

//计算机学院
public class ComputerCollege implements College{
    
    private Department[] departments;
    //当前数组对象个数
    int numOfDepartment = 0;
    
    public ComputerCollege(){
        departments = new Department[5];
    }
    
    @Override
    public String getName(){
        return "计算机学院";
    }
    
    @Override
    public void addDepartment(String name,String desc){
        Department department = new Department(name,desc);
        departments[numOfDepartment] = department;
        numOfDepartment++;
    }
    
    @Override
    public Iterator createIterator(){
        return new ComputerCollegeIterator(departments);
    } 
}

//信息工程学院
public class InfoCollege implements College{
    
    private List<Department> departmentList;
    
    public InfoCollege(){
        departmentList = new ArrayList();
    }
    
    @Override
    public String getName(){
        return "信息工程学院";
    }
    
    @Override
    public void addDepartment(String name,String desc){
        Department department = new Department(name,desc);
        departmentList.add(department);
    }
    
    @Override
    public Iterator createIterator(){
        return new InfoColleageIterator(departmentList);
    } 
}

输出类

public class OutPutImpl{
    //学院集合
	List<College> collegeList;
    
    public OutPutImpl(List<College> collegeList){
        this.collegeList = collegeList;
    }
    //遍历学院，然后调用printDepartment
    public void printCollege(){
        Iterator<College> iterator = collegeList.iterator();
        where(iterator.hasNext()){
            //得到学院
            College college = iterator.naxt();
            System.out.println(college.getName());
            //输出系
            printDepartment(college.createIterator());
        }
    }
    
    //输出 学院输出系
    public void printDepartment(Iterator iterator){
        while(iterator.hasNext()){
            Department department = (Department) iterator.next();
            System.out.println(department.getName());
        }
    } 
}

测试

List<College> collegeList = new ArrayList();
//信息工程学院
InfoCollege infoCollege = new InfoCollege();
infoCollege.addDepartment("信息1","信息1");
infoCollege.addDepartment("信息2","信息2");
collegeList.add(infoCollege);
//计算机学院
ComputerCollege computerCollege = new ComputerCollege();
computerCollege.addDepartment("计算机1","计算机1");
computerCollege.addDepartment("计算机2","计算机2");
collegeList.add(computerCollege);
//输出
new OutPutImpl(collegeList).printCollege();

总结

优点：

  • 提供一个统一的方法遍历对象，客户端不用再考虑聚合的类型，使用一种方法就可以遍历对象了
  • 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不知道聚合的具体组成
  • 提供了一种设计思想，就是一个类应该只有一个引起变化的原因。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变，只影响到了迭代器
  • 当要展示一组相似的对象，或者遍历一组相同对象时使用，适合使用迭代器模式

缺点

  • 每个聚合对象都要一个迭代器，会生成多个迭代器不好管理
设计模式