软件设计迭代器模式（high）Iterator Pattern

作者：@kuaiquxie
作者的github：https://github.com/bitebita
本文为作者原创，如需转载，请注明出处：https://www.cnblogs.com/dzwj/p/17111692.html

迭代器模式是 Java 中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，而不需要知道集合对象的底层表示。

迭代器是学习 Java 语言的基础，没有迭代器，集合类的遍历就成了问题，正是因为有迭代器的存在，才能更加优雅的使用 foreach 语法。

代码实现：

Java 中的增强 for 循环是使用迭代器实现的：

List<String> list = Arrays.asList("AAA", "BBB", "CCC");
// 使用 foreach 语法糖进行迭代，依次获取每一个元素
for (String s : list) {
    // 打印元素
    System.out.println(s);
}

编译之后的代码如下：

List<String> list = Arrays.asList("AAA", "BBB", "CCC");
// 这里本质是通过 List 生成的迭代器来遍历每个元素的
Iterator var2 = list.iterator();
// 判断是否还有元素可以迭代，没有就返回false
while(var2.hasNext()) {
    // 通过 next 方法得到下一个元素，每调用一次，迭代器会向后移动一位
    String s = (String)var2.next();
    // 打印元素
    System.out.println(s);
}
可以看到，当使用迭代器对 List 进行遍历时，实际上就像是在操作一个指向列表头部的指针，通过不断向后移动指针来依次获取所指向的元素。

1.这里依照 JDK 提供的迭代器接口（JDK 已经定义好了一个迭代器的具体相关操作接口），也来设计一个迭代器：

1、定义数组集合

/**
 * 数组集合<br>
 * 实现 Iterable 接口表示此类是支持迭代的
 */
public class ArrayCollection<T> implements Iterable<T> {
    /**
     * 使用数组来存放数据
     */
    private final T[] array;
    /**
     * 构造器私有，自己用
     * @param array 数组
     */
    private ArrayCollection(T[] array) {
        this.array = array;
    }
    /**
     * 使用静态方法获取对象
     * @param array 数组
     * @return 数组集合对象
     * @param <T> 实体类
     */
    public static <T> ArrayCollection<T> of(T[] array) {
        return new ArrayCollection<>(array);
    }
    /**
     * 实现 iterator 方法，此方法会返回一个迭代器，用于迭代我们集合中的元素
     * @return 迭代器
     */
    @Override
    public Iterator<T> iterator() {
        return new ArrayIterator();
    }
    /**
     * 这里自定义 ArrayIterator，注意别用静态，需要使用对象中存放的数组
     */
    public class ArrayIterator implements Iterator<T> {
        // 这里通过指针表示当前的迭代位置
        private int index = 0;
        /**
         * 判断是否还有下一个元素
         * @return 结果
         */
        @Override
        public boolean hasNext() {
            // 如果指针大于或等于数组最大长度，就不能再继续了
            return index < array.length;
        }
        /**
         * 返回当前指针位置的元素并向后移动一位
         * @return
         */
        @Override
        public T next() {
            // 正常返回对应位置的元素，并将指针自增
            return array[index++];   
        }
    }
}
2、调用

// 定义数组
String[] arr = new String[]{"AAA", "BBB", "CCC", "DDD"};
// 使用数组集合处理数组
ArrayCollection<String> collection = ArrayCollection.of(arr);
// 使用 foreach 语法糖遍历，最后还是会变成迭代器调用
for (String s : collection) {
    System.out.println(s);
}
编译后的代码为：

String[] arr = new String[]{"AAA", "BBB", "CCC", "DDD"};
ArrayCollection<String> collection = ArrayCollection.of(arr);
// 首先获取迭代器，实际上就是调用我们实现的 iterator 方法
Iterator var3 = collection.iterator();
while(var3.hasNext()) {
    // 使用 next() 方法不断向下获取
    String s = (String)var3.next();
    System.out.println(s);
}
输出结果为：

AAA
BBB
CCC
DDD
这样就实现了自定义迭代器来遍历数组。

2.迭代器遍历学生list


1.学生类
package com17.diedai;

public class Student implements Comparable<Student> {

    private String name;
    private int sid;
    private int age;

    public Student(String name, int sid, int age) {
        this.name = name;
        this.sid = sid;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "姓名='" + name + '\'' +
                ", 学号=" + sid +
                ", 年龄=" + age +
                '}';
    }

//    比较两个相同类型的值
    @Override
    public int compareTo(Student o) {
        if (this.sid > o.sid){
            return -1;
        } else if (this.sid < o.sid){
            return 1;
        } else {
            return 0;
        }
    }
}

2.调用
package com17.diedai;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        Student student1 = new Student("张三",1,21);
        Student student2 = new Student("李四",2,20);
        Student student3 = new Student("张三2",3,23);

        List<Student> list = new ArrayList<Student>();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        Collections.sort(list);

        System.out.println("按学号由大到小排序输出：");
        Iterator i = list.iterator();
        while (i.hasNext()){
            System.out.println(i.next().toString());
        }

    }

}

3.输出结果
    
按学号排序输出：
Student{姓名='张三2', 学号=3, 年龄=23}
Student{姓名='李四', 学号=2, 年龄=20}
Student{姓名='张三', 学号=1, 年龄=21}