迭代器模式--更高、更快、更强（行为模式09）

什么是迭代器模式
提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。
迭代器模式又称为游标模式，迭代器模式是一个元老级别的设计模式，针对容器的访问，我们java中要设计遍历算法，迭代器算是客户端与系统之间的第三者，方便遍历应运而生。

迭代器模式的适用场景
遍历容器内对象

迭代器模式用例
好比我们高校Java专业有两个班级JavaOne和JavaTwo，辅导员想要获取所有学生的姓名、年龄、性别的信息，最笨的方法是导员自己一个一个去问。但是导员比较忙，所以是时候体现班长的作用了，班长就是具体的迭代器类，班长自己去一个一个统计，然后把数据罗列出来，然后两个班长把数据统一交给辅导员，辅导员只需要调用班长的类就可以实现遍历所有学生的信息。

UML类图

Student实体类：

public class Student {
    private String name;
    private String sex;
    private int age;

    public Student(String name,String sex,int age){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //自定义覆写toString方法实现
    public String toString(){
        return "姓名:"+name+"  性别:"+sex+"  年龄:"+age;
    }
}

Iterator接口：

public interface Iterator {
    boolean hasNext();
    Object next();
}

Iterator实现类：（一班班长遍历算法，一班班长用了list存储数据）

public class ClassOneIterator implements Iterator {

    private List<Student> list;
    private int position;
    public ClassOneIterator(List<Student> list){
        this.list = list;
    }
    @Override
    public boolean hasNext() {
        return !(position > list.size() - 1 || list.get(position) == null);
    }

    @Override
    public Object next() {
        Student stu = list.get(position);
        position++;
        return stu;
    }

}

Iterator接口实现类：（二班班长遍历算法，二班班长用了数组）

public class ClassTwoIterator implements Iterator {

    private Student[] array;
    private int position;

    public ClassTwoIterator(Student[] array){
        this.array = array;
    }
    @Override
    public boolean hasNext() {
        return !(position > array.length - 1 || array[position] == null);
    }

    @Override
    public Object next() {
        Student stu = array[position];
        position++;
        return stu;
    }

}

接口ClassJava实现：（班长需要遍历操作）

public interface ClassJava {
    Iterator iterator();
}

ClassJava接口实现类：ClassOne（一班班长统计的数据）

public class ClassOne implements ClassJava {

    private List<Student> list = new ArrayList<>();

    public ClassOne(){
        list.add(new Student("张三","男",23));
        list.add(new Student("李四","女",19));
        list.add(new Student("王五","男",26));
        list.add(new Student("赵六","女",18));
    }

    @Override
    public Iterator iterator() {
        return new ClassOneIterator(list);
    }

}

ClassJava接口实现类：ClassTwo（二班班长统计的数据）

public class ClassTwo implements ClassJava {

    private Student[] array = new Student[5];

    public ClassTwo(){
        array[0] = new Student("小王","男",23);
        array[1] = new Student("小李","女",29);
        array[2] = new Student("小能","男",23);
        array[3] = new Student("小六","男",19);
        array[4] = new Student("小五","女",22);
    }

    @Override
    public Iterator iterator() {
        return new ClassTwoIterator(array);
    }

}

辅导员综合查看数据：测试类

public class Test {

    public static void main(String[] args) {
        //让一班班长去统计一般信息并报告结果
        ClassOne one = new ClassOne();
        getStudentInfo(one.iterator());
        //让二班班长去统计二班信息并报告结果
        ClassTwo two = new ClassTwo();
        getStudentInfo(two.iterator());
    }

    private static void getStudentInfo(Iterator iterator){
        while(iterator.hasNext()){
            System.out.println(iterator.next().toString());
        }
    }

}

运行结果：

姓名:张三  性别:男  年龄:23
姓名:李四  性别:女  年龄:19
姓名:王五  性别:男  年龄:26
姓名:赵六  性别:女  年龄:18
姓名:小王  性别:男  年龄:23
姓名:小李  性别:女  年龄:29
姓名:小能  性别:男  年龄:23
姓名:小六  性别:男  年龄:19
姓名:小五  性别:女  年龄:22

---

以上是我们自定义的迭代器，而jdk内置也有迭代器，与之不同的是他设计的更完善。迭代器和for循环都可以完成遍历操作，区别在于for循环遍历过程中不能更改容器的大小，而迭代器则可以通过remove()方法来更改容器大小；效率上for循环适合随机访问比如Arraylist，而迭代器适合顺序访问比如LinkedList。因为for循环使用下标来获取元素位置，而迭代器通过next(),pre()来定位元素，可以访问无序结构。所以如果需要迁移数据到set这种无序的结构的话，for循环要调整迭代器无需调整。

迭代器模式总结
优点：弱化了容器类与遍历算法之间的关系
缺点：类文件增加
对各种语言来说，迭代器已经开发的相当完善了，所以对于开发者而言不需要自己去动手实现太多，当然如果的确有需要的话。