【设计模式】行为型模式4——迭代器模式

优点
迭代器模式分离了容器对象的遍历操作，符合单一职责原则

缺点
每个具体容器需要添加一个对应的迭代器

/**
 * 角色（Object）
 */
public class Student {

    private String name;

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

/**
 * 角色（Aggregate）
 */
public abstract class School {

    public abstract Iterator createIterator();

    public abstract void add(String studentName);
}

迭代器与容器共用相同数据结构，且有一一对应关系，参照Collection源码写成内部类

public class PrimarySchool extends School{

    private Student[] students;
    private int addIndex;
    private int index;

    public PrimarySchool() {
        addIndex = 0;
        index = 0;
        this.students = new Student[5];
    }

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

    @Override
    public void add(String studentName) {
        students[this.addIndex++] = new Student(studentName);
    }

    public class PrimarySchoolIterator implements Iterator{

        @Override
        public boolean hasNext() {
            if(students == null || index >= students.length){
                return false;
            }
            return true;
        }

        @Override
        public Object next() {
            return students[index++];
        }
    }
}



public class HighSchool extends School{

    private List<Student> students;
    private int index;

    public HighSchool() {
        index = 0;
        this.students = new ArrayList<>();
    }

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

    @Override
    public void add(String studentName) {
        students.add(new Student(studentName));
    }

    public class HighSchoolIterator implements Iterator{

        @Override
        public boolean hasNext() {
            if(students == null || index >= students.size()){
                return false;
            }
            return true;
        }

        @Override
        public Object next() {
            return students.get(index++);
        }
    }
}

测试类

    public static void main(String[] args) {
        PrimarySchool primarySchool = new PrimarySchool();
        primarySchool.add("小学生1");
        primarySchool.add("小学生2");
        primarySchool.add("小学生3");
        primarySchool.add("小学生4");
        primarySchool.add("小学生5");

        Iterator primarySchoolIterator = primarySchool.createIterator();
        System.out.println("=============================小学学生============================");
        while(primarySchoolIterator.hasNext()){
            Student next = (Student) primarySchoolIterator.next();
            System.out.println(next.getName());
        }


        HighSchool highSchool = new HighSchool();
        highSchool.add("高中生a");
        highSchool.add("高中生b");
        highSchool.add("高中生c");
        highSchool.add("高中生d");
        highSchool.add("高中生e");
        Iterator highSchoolIterator = highSchool.createIterator();
        System.out.println("=============================高中学生============================");
        while(highSchoolIterator.hasNext()){
            Student next = (Student) highSchoolIterator.next();
            System.out.println(next.getName());
        }


    }

结果

jdk补充

实际上for-each语法糖背后对集合使用的便是迭代器方法，而对数组使用的就是fori循环
但倘若在遍历之时对其使用remove()则会因为实际引用与集合变化的原因使遍历异常，问题具体描述