设计模式之迭代器模式(1)：封装你的集合迭代逻辑

前言

参考:http://c.biancheng.net/view/1...

1. 现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”---一个软件实体如类、模块和函数应该对扩展开放，对修改关闭(Softeware entities like classes,modules and functions should be open for extension but closed for modifications.)。
2. 既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点：

1.暴露了聚合类的内部表示，使其数据不安全；
2.增加了客户的负担

“迭代器模式”能较好地克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”，java中Collection、List、Set、Map 等都包含了迭代器。

内容

1.迭代器的定义与特点

迭代器（Iterator）模式的定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。迭代器模式是一种对象行为型模式

主要优点如下：
1.访问一个聚合对象的内容而无须暴露它的内部表示。
2.遍历任务交由迭代器完成，这简化了聚合类。
3.它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
4.增加新的聚合类和迭代器类都很方便，无须修改原有代码。
5.封装性良好，为遍历不同的聚合结构提供一个统一的接口。

其主要缺点是：增加了类的个数，这在一定程度上增加了系统的复杂性。

2.迭代器模式的结构

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。现在我们来分析其基本结构与实现方法。

迭代器模式结构主要包含以下角色。

1. 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
2. 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
3. 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
4. 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

3.迭代器模式的实例

需求:现在假设,有一个教室类，里面有一堆学生，我们现在遍历学生并打印输出。

3.1 不使用设计模式

不使用设计模式时候遍历。

/**
* 不用模式实现
* @author yxm
* @date 2020/3/14
**/
public class NonPatternApplication {

   public static void main(String[] args) {
       //1.不使用设计模式情况下遍历聚合类中数据
       Student stu1 = new Student("小明");
       Student stu2 = new Student("小王");
       Student[] students = new Student[2];
       students[0]=stu1;
       students[1]=stu2;

       Classroom classroom = new Classroom();  
       classroom.setStudents(students);

       Student[] classroomStudents = classroom.getStudents();
       for(Student stu:classroomStudents){
           System.out.println(stu);
       }
   }


   /**
    * 学生类
    */
   public static 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;
       }
       @Override
       public String toString() {
           return "Student{" +
                   "name='" + name + '\'' +
                   '}';
       }
   }

   /**
    * 教室类
    */
   public static class Classroom{
       private Student[] students;

       public void setStudents(Student[] students){
           this.students = students;
       }

       public Student[] getStudents(){
           return this.students;
       }
   }
}

现在我们更改下Classroom聚合类里面集合类型为:map。

此时我们发现一旦聚合类里面数据集合类型变动,那么所有之前遍历聚合类的方法将会失效。在我们实际开发中聚合类和聚合类的遍历也许是2个团队开发的,如果使用传统遍历方式,那么一旦聚合类开发者改动了聚合类集合类型，那么遍历调用者也会修改代码。这种问题是很严重的。

public class IteratorPatternApplication {
    public static void main(String[] args) {
        //1.构建聚合类
        Student stu1 = new Student("张三");
        Student stu2 = new Student("李四");

        Classroom classroom = new Classroom(2);
        classroom.addStudents(stu1);
        classroom.addStudents(stu2);

        //遍历
        Iterator iterator = classroom.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    /**
     * 代表了一个集合类(聚合类)接口
     */
    public interface Aggregate{
        public abstract Iterator iterator();
    }

    /**
     * 定义一个迭代器接口
     */
    public interface Iterator{
        public abstract boolean hasNext();
        public abstract  Object next();
    }

    public static class ClassroomIterator implements Iterator{
         private Classroom classroom;
         private int index;

         public ClassroomIterator(Classroom classroom){
             this.classroom = classroom;
             this.index = 0;
         }

        public boolean hasNext() {
             if(index<classroom.getLength()){
                 return true;
             }
             return false;
        }

        public Object next() {
            Student students = classroom.getStudents(this.index);
            index++;
            return students;
        }
    }

    /**
     * 教室类
     */
    public static class Classroom implements Aggregate{
        private Student[] students;
        /**
         * last相当于是数组长度
         */
        private int last = 0;

        public Classroom(int size){
            this.students= new Student[size];
        }

        public Student getStudents(int index){
            return this.students[index];
        }

        public void addStudents(Student  student){
            this.students[last] = student;
            last++;
        }

        public int getLength(){
            return last;
        }

        public Iterator iterator() {
            ClassroomIterator classroomIterator = new ClassroomIterator(this);
            return classroomIterator;
        }
    }


    /**
     * 学生类
     */
    public static 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;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
}

我们更换里面的Student[] 为List,遍历结果不变。

public class IteratorPatternApplication {
    public static void main(String[] args) {
        //1.构建聚合类
        Student stu1 = new Student("张三");
        Student stu2 = new Student("李四");

        Classroom classroom = new Classroom(2);
        classroom.addStudents(stu1);
        classroom.addStudents(stu2);

        //遍历
        Iterator iterator = classroom.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    /**
     * 代表了一个集合类(聚合类)接口
     */
    public interface Aggregate{
        public abstract Iterator iterator();
    }

    /**
     * 定义一个迭代器接口
     */
    public interface Iterator{
        public abstract boolean hasNext();
        public abstract  Object next();
    }

    public static class ClassroomIterator implements Iterator{
         private Classroom classroom;
         private int index;

         public ClassroomIterator(Classroom classroom){
             this.classroom = classroom;
             this.index = 0;
         }

        public boolean hasNext() {
             if(index<classroom.getLength()){
                 return true;
             }
             return false;
        }

        public Object next() {
            Student students = classroom.getStudents(this.index);
            index++;
            return students;
        }
    }

    /**
     * 教室类
     */
    public static class Classroom implements Aggregate{
       // private Student[] students;
        private List<Student> students;
        /**
         * last相当于是数组长度
         */
        private int last = 0;

        public Classroom(int size){
            //this.students= new Student[size];
            this.students = new ArrayList<Student>(2);
        }

        public Student getStudents(int index){
            //this.students[index];
            return this.students.get(index);
        }

        public void addStudents(Student  student){
            //this.students[last] = student;
            this.students.add(student);
            last++;
        }

        public int getLength(){
            return last;
        }

        public Iterator iterator() {
            ClassroomIterator classroomIterator = new ClassroomIterator(this);
            return classroomIterator;
        }
    }


    /**
     * 学生类
     */
    public static 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;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
}