Java设计模式之迭代器模式解析

public interface StudentIterator {
    // 判断是否还有元素
    boolean hasNext();
    // 获取下一个元素
    Student next();
}

public class StudentIteratorImpl implements StudentIterator {
    private List<Student> list;
    private int position = 0; // 记录遍历时的位置
    public StudentIteratorImpl(List<Student> list) {
        this.list = list;
    }
    // 判断是否还有元素
    @Override
    public boolean hasNext() {
        return position < list.size();
    }
    // 获取下一个元素
    @Override
    public Student next() {
        // 从集合中获取指定位置的元素
        Student currentStudent = list.get(position);
        position++;
        return currentStudent;
    }
}

public interface StudentAggregate {
    // 添加学生功能
    void addStudent(Student student);
    // 删除学生功能
    void removeStudent(Student student);
    // 获取迭代器对象功能
    StudentIterator getStudentIterator();
}

public class StudentAggregateImpl implements StudentAggregate {
    private List<Student> list = new ArrayList<Student>(); // 学生列表
    // 添加学生功能
    @Override
    public void addStudent(Student student) {
        this.list.add(student);
    }
    // 删除学生功能
    @Override
    public void removeStudent(Student student) {
        this.list.remove(student);
    }
    // 获取迭代器对象功能
    @Override
    public StudentIterator getStudentIterator() {
        // 创建迭代器对象
        return new StudentIteratorImpl(list);
    }
}

public class Student {
    private String name;
    private String number;
    // getter/setter...
    public Student(String name, String number) {
        this.name = name;
        this.number = number;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", number='" + number + '\'' +
                '}';
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建聚合对象
        StudentAggregateImpl aggregate = new StudentAggregateImpl();
        // 添加元素
        aggregate.addStudent(new Student("张三", "001"));
        aggregate.addStudent(new Student("李四", "002"));
        aggregate.addStudent(new Student("王五", "003"));
        aggregate.addStudent(new Student("赵六", "004"));
        /*
         * 遍历聚合对象
         */
        // 1.获取迭代器对象
        StudentIterator iterator = aggregate.getStudentIterator();
        // 2.遍历
        while (iterator.hasNext()) {
            // 3.获取元素
            Student student = iterator.next();
            System.out.println(student.toString());
        }
    }
}

List<String> list = new ArrayList<>();
Iterator<String> iterator = list.iterator(); // list.iterator()方法返回的肯定是Iterator接口的子实现类对象
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    public Iterator<E> iterator() {
        // 返回的肯定是Iterator的子实现类对象
        return new Itr();
    }
    			   ||
                   \/
    // 内部类Itr 实现了Iterator接口 并且重写了 hasNext() 和 next() 方法。
    private class Itr implements Iterator<E> {
        int cursor;       // 下一个要返回元素的索引
        int lastRet = -1; // 上一个返回元素的索引
        int expectedModCount = modCount;
        Itr() {}
        // 判断是否还有元素
        public boolean hasNext() {
            return cursor != size;
        }
        // 获取下一个元素
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
        ...
}