設計模式之迭代器模式

迭代器模式

行爲型模式

迭代器模式（Iterator Pattern）是 Java 和 .Net 編程環境中很是經常使用的設計模式。這種模式用於順序訪問集合對象的元素，不須要知道集合對象的底層表示。

介紹

意圖： 提供一種方法順序訪問一個聚合對象中各個元素, 而又無須暴露該對象的內部表示。

主要解決： 不一樣的方式來遍歷整個整合對象。

什麼時候使用： 遍歷一個聚合對象。

如何解決： 把在元素之間遊走的責任交給迭代器，而不是聚合對象。

關鍵代碼： 定義接口：hasNext, next。

應用實例： JAVA 中的 iterator。

具體實現

咱們在控制檯須要輸出一個學校的院系組成，一個學校有多個學院，一個學院有多個系。

第一步：建立系

public class Department {

    private String name;
    private String desc;

    public String getName() {
        return name;
    }

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

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

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

第二步：建立學院接口

public interface College {

    String getName();

    /**
     * 增長系
     */
    void addDepartment(String name, String desc);

    //返回一個迭代器
    Iterator<Department> createIterator();

}

第三步：建立不一樣院系的實現類

public class ComputerCollege implements College {

    private Department[] departments;
    //保存當前數組對象的個數
    private int numOfDepartment = 0;

    public ComputerCollege() {
        departments = new Department[5];
        addDepartment("Java", "很棒");
        addDepartment("PHP", "不行");
        addDepartment("Python", "也很棒");
        addDepartment("JS", "也是很棒");
    }

    @Override
    public String getName() {
        return "計算機學院";
    }

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

    @Override
    public Iterator<Department> createIterator() {
        return new ComputerCollegeIterator(departments);
    }
}

public class InfoCollege implements College {

    private List<Department> departments;

    public InfoCollege() {
        departments = new ArrayList<>();
        addDepartment("信息安全專業", "很棒");
        addDepartment("網絡安全專業", "good");
        addDepartment("服務器安全專業", "也很棒");
    }

    @Override
    public String getName() {
        return "信息學院";
    }

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

    @Override
    public Iterator<Department> createIterator() {
        return new InfoCollegeIterator(departments);
    }
}

第四步：建立不一樣學院的迭代器實現Iterator接口

public class ComputerCollegeIterator implements Iterator<Department> {

    //這裏咱們須要知道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;
        }
        return true;
    }

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

public class InfoCollegeIterator implements Iterator<Department> {

    //信息工程學院是以List的方式存放系
    private List<Department> departments;
    //索引
    private int index = -1;

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


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

    @Override
    public Department next() {
        return departments.get(index);
    }
}

第五步：建立輸出類

public class OutPutImpl {

    //學院的集合
    private List<College> collegeList;

    public OutPutImpl(List<College> collegeList) {
        this.collegeList = collegeList;
    }

    //遍歷全部學院,而後調用printDepartment輸出系
    public void printCollege() {
        Iterator<College> iterator = collegeList.iterator();
        while (iterator.hasNext()) {
            College college = iterator.next();
            System.out.println("---------學院名稱:" + college.getName() + "---------");
            printDepartment(college.createIterator());
        }
    }

    //輸出 系
    public void printDepartment(Iterator<Department> iterator) {
        while (iterator.hasNext()) {
            Department department = iterator.next();
            System.out.println("系名稱:" + department.getName() + ",簡介:" + department.getDesc());
        }
    }
}

第六步：建立測試類

public class Client {

    public static void main(String[] args) {
        //建立學院
        List<College> collegeList = new ArrayList<>();
        ComputerCollege computerCollege = new ComputerCollege();
        InfoCollege infoCollege = new InfoCollege();
        collegeList.add(computerCollege);
        collegeList.add(infoCollege);
        OutPutImpl outPut = new OutPutImpl(collegeList);
        outPut.printCollege();
    }
}

運行以下：

---------學院名稱:計算機學院---------
系名稱:Java,簡介:很棒
系名稱:PHP,簡介:不行
系名稱:Python,簡介:也很棒
系名稱:JS,簡介:也是很棒
---------學院名稱:信息學院---------
系名稱:信息安全專業,簡介:很棒
系名稱:網絡安全專業,簡介:good
系名稱:服務器安全專業,簡介:也很棒

優勢：

    一、它支持以不一樣的方式遍歷一個聚合對象。 二、迭代器簡化了聚合類。 三、在同一個聚合上能夠有多個遍歷。 四、在迭代器模式中，增長新的聚合類和迭代器類都很方便，無須修改原有代碼。

缺點：

    因爲迭代器模式將存儲數據和遍歷數據的職責分離，增長新的聚合類須要對應增長新的迭代器類，類的個數成對增長，這在必定程度上增長了系統的複雜性。