迭代器模式

基本介绍

1. 迭代器模式是常用的设计模式，属于行为型模式
2. 如果集合元素是以不同的方式实现的，当调用者要遍历这些集合元素，就要用到多种遍历方式，而且还会暴露内部结构，这个时候就可以使用迭代器模式进行统一遍历
3. 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不知道集合对象的底层表示，不暴露内部结构

原理

1. Iterator：迭代器接口，jdk提供
2. ConcreteIterator：具体的迭代器类，管理迭代
3. Aggregate：一个统一的聚合集合接口，将调用者和集合解耦
4. ConcreteAggregate：持有对象集合，并提供一个可以返回迭代器的方法

实例

/***
 * @author shaofan
 * @Description 迭代器模式完成学院部门遍历
 */
public class MyIterator {
    public static void main(String[] args) {
        ComputerCollege computerCollege = new ComputerCollege();
        computerCollege.add(new Department("软件工程"));
        computerCollege.add(new Department("计算机科学与技术"));

        InfoCollege infoCollege = new InfoCollege(10);
        infoCollege.add(new Department("信息工程"));

        Output.output(computerCollege);
        System.out.println();
        Output.output(infoCollege);
    }
}

class ComputerCollegeIterator implements Iterator<Department>{
    List<Department> data;
    int position;
    public ComputerCollegeIterator(List<Department> data){
        this.data = data;
        position = 0;
    }

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

    @Override
    public Department next() {
        return data.get(position++);
    }
}

class InfoCollegeIterator implements Iterator<Department>{
    Department[] data;
    int position;
    public InfoCollegeIterator(Department[] data){
        this.data = data;
        position = 0;
    }

    @Override
    public boolean hasNext() {
        return position<data.length;
    }

    @Override
    public Department next() {
        return data[position++];
    }
}

class Department{
    private String name;
    public Department(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    @Override
    public String toString(){
        return this.name;
    }
}

abstract class College{
    abstract Iterator<Department> createIterator();
}

class ComputerCollege extends College{
    private List<Department> data;
    public ComputerCollege(){
        data = new ArrayList<>();
    }
    public void add(Department department){
        data.add(department);
    }

    @Override
    Iterator<Department> createIterator() {
        return new ComputerCollegeIterator(data);
    }
}
class InfoCollege extends College{
    private Department[] data;
    int index = 0;
    public InfoCollege(int size){
        data = new Department[size];
    }

    public void add(Department department){
        data[index++] = department;
    }

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

class Output{
    public static void output(College college){
        Iterator<Department> it = college.createIterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

}

源码分析

jdk的各个集合，都实现了各自的迭代器
ArrayList

LinkedList

对不同的数据结构，迭代器可以提供统一的遍历方式

总结

优点

1. 提供了一个统一的方法遍历对象那个，客户不用再考虑集合类型
2. 隐藏了集合的内部结构，客户端要遍历集合是只需要取到迭代器，不用知道内部组成
3. 提供了一种设计思想，一个类应该只有一个引起变化的原因，再集合类中吧迭代器分开，就是把管理对象集合和遍历对象集合的责任分开
   缺点
   每个聚合对象都要一个迭代器，会产生多个迭代器类