JAVA设计模式(迭代器模式）

迭代器模式提供了遍历集合的统一接口，用一致的方式遍历元素，而不需要知道集合元素的统一表示，即不暴露内部结构。迭代器模式属于行为型的模式。

JAVA迭代器接口有三个方法

package java.util;
public interface Iterator<E> {
    boolean hasNext();//判断是否存在下一个对象元素
    E next();//获取下一个元素
    void remove();//移除元素
}

JAVA集合中迭代器的使用

public class Test {
    public static void main(String[] args) {
        List<String> list=new ArrayList();
        list.add("张三");
        list.add("李四");
        Iterator iterator=list.iterator();
        while(iterator.hasNext())
        {
            System.out.println(iterator.next());
        }
    }
}

迭代器模式体现了单一责任的原则，使用迭代器模式，可以把管理对象集合和遍历对象集合的责任分开。

类图

案例：
学校中有多个学院，学院下面有多个系，现在多个系以不同的方式存储在学院中，现在需要设计程序遍历出学院和系。本案例适合使用迭代器模式，使用相同的方式遍历集合，而不需要知道集合的内部结构。

专业类

public class Department {
    private String name;
    private String des;

    public Department(String name, String des) {
        this.name = name;
        this.des = des;
    }

    public String getName() {
        return name;
    }

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

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }

}

College类及其子类

public interface College {
    public String getName();
    public void addDepartment(String name,String des);
    public Iterator createIterator();
}
public class ComputerCollege implements College {
    Department[] departments;
    int numOfDepartment=0;//保存当前数组的对象个数

    public ComputerCollege(){
      departments=new Department[5];
      addDepartment("JAVA专业","JAVA专业");
        addDepartment("PHP专业","PHP专业");
        addDepartment("大数据专业","大数据专业");
        addDepartment("网络专业","网络专业");

    }
    @Override
    public String getName() {
        return "计算机学院";
    }

    @Override
    public void addDepartment(String name, String des) {
       Department department=new Department(name,des);
       departments[numOfDepartment]=department;
       numOfDepartment+=1;
    }

    @Override
    public Iterator createIterator() {
        return new ComputerCollegeIterator(departments);
    }
}
public class InfoCollege implements College {
    List<Department> departmentList;
    public InfoCollege(){
        departmentList=new ArrayList<Department>();
        addDepartment("电子信息工程","电子信息工程");
        addDepartment("通信工程","通信工程");
    }
    @Override
    public String getName() {
        return "信息工程学院";
    }

    @Override
    public void addDepartment(String name, String des) {
        Department department=new Department(name,des);
        departmentList.add(department);
    }

    @Override
    public Iterator createIterator() {
        return new InfoCollegeIterator(departmentList);
    }
}

迭代器的实现类

public class ComputerCollegeIterator implements Iterator {
    //Department是否是以怎样的方式实现=》数组
    Department[] departments;
    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;
        }
    }

    @Override
    public Object next() {
        Department department=departments[position];
        position+=1;
        return department;
    }

    @Override
    public void remove() {
    }
}
public class InfoCollegeIterator implements Iterator {

    List<Department>  departmentList;
    int index=-1;

    public InfoCollegeIterator(List<Department> departmentList) {
        this.departmentList = departmentList;
    }

    @Override
    public boolean hasNext() {
        if (index >= departmentList.size() - 1) {
            return false;
        } else {
            index += 1;
            return true;
        }
    }
    @Override
    public Object next() {
        return departmentList.get(index);
    }

    @Override
    public void remove() {
    }
}

输出类

public class OutputImpl {
    List<College>  collegesList;

    public OutputImpl(List<College> collegesList) {
        this.collegesList = collegesList;
    }
    public void printCollegeList(){
        Iterator iterator=collegesList.iterator();
        while(iterator.hasNext()){
            College c= (College) iterator.next();
            System.out.println("==="+c.getName()+"===");
            printDepartment(c.createIterator());
        }
    }
    public void printDepartment(Iterator iterator){
        while(iterator.hasNext()){
            Department d= (Department) iterator.next();
            System.out.println(d.getName());
        }
    }
}

客户端调用

public class Client {
    public static void main(String[] args) {
        List<College> collegeList=new ArrayList<>();
        InfoCollege infoCollege=new InfoCollege();
        ComputerCollege computerCollege=new ComputerCollege();
        collegeList.add(infoCollege);
        collegeList.add(computerCollege);
        OutputImpl output=new OutputImpl(collegeList);
        output.printCollegeList();
    }
}

迭代器模式的缺点是对于每一个集合，都要实现迭代器的方法。