迭代器模式

    又稱爲遊標模式, 它提供一種順序集合、容器對象元素的方法, 而又無須暴露集合內部表示。
     特徵: 抽離集合對象迭代行爲到迭代器中, 提供一致訪問接口
    屬於行爲型模式

適用場景:
    一、訪問一個集合對象的內容而無須暴露它的內部表示
    二、爲遍歷不一樣的集合結構提供一個統一的訪問接口

public interface Iterator<E> {

    /**
     * 獲取下一個
     * @return
     */
    E next();

    /**
     * 是否存在下一個
     * @return
     */
    boolean hasNext();

}

public interface IAggregate<E> {
    /**
     * 添加
     * @param element
     * @return
     */
    boolean add(E element);

    /**
     * 移除
     * @param element
     * @return
     */
    boolean remove(E element);

    /**
     * 迭代器
     * @return
     */
    Iterator<E> iterator();
}

public class ConcreteIterator<E> implements Iterator<E> {

    private  List<E> list;

    private int cursor = 0;

    public ConcreteIterator(List<E> list) {
        this.list = list;
    }

    @Override
    public E next() {
        return this.list.get(this.cursor++);
    }

    @Override
    public boolean hasNext() {
        return this.cursor < this.list.size();
    }

}

public class ConcreteAggregate<E> implements IAggregate<E> {
    private List<E> list = new ArrayList<>();

    @Override
    public boolean add(E element) {
        return this.list.add(element);
    }

    @Override
    public boolean remove(E element) {
        return this.list.remove(element);
    }

    @Override
    public Iterator<E> iterator() {
        return new ConcreteIterator<>(this.list);
    }

}

public static void main(String[] args) {

    IAggregate<String> aggregate = new ConcreteAggregate<>();

    aggregate.add("110");
    aggregate.add("119");
    aggregate.add("120");

    Iterator<String> iterator = aggregate.iterator();

    while (iterator.hasNext()) {
        String element = iterator.next();
        System.out.println(element);
    }
}

===================================================================================

public class Course {

    private String name;

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

    public String getName() {
        return name;
    }

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

public interface iterator<E> {
    /**
     * 下一個元素
     * @return
     */
    E next();

    /**
     * 是否存在下一個
     * @return
     */
    boolean hasNext();

}

public interface ICourseAggregate {

    /**
     * 添加
     *
     * @param course
     */
    void add(Course course);

    /**
     * 刪除
     *
     * @param course
     */
    void remove(Course course);

    /**
     * 迭代
     *
     * @return
     */
    Iterator<Course> iterator();
}

public class IteratorImpl<E> implements Iterator<E> {

    private List<E> list;

    private int cursor;

    private E element;

    public IteratorImpl(List<E> list) {
        this.list = list;
    }


    @Override
    public E next() {
        System.out.print("當前位置: " + cursor + " : ");
        element = list.get(cursor);
        cursor++;
        return element;
    }

    @Override
    public boolean hasNext() {

        if (cursor > list.size() - 1) {
            return false;
        }

        return true;
    }


}

public class IteratorImpl<E> implements Iterator<E> {

    private List<E> list;

    private int cursor;

    private E element;

    public IteratorImpl(List<E> list) {
        this.list = list;
    }


    @Override
    public E next() {
        System.out.print("當前位置: " + cursor + " : ");
        element = list.get(cursor);
        cursor++;
        return element;
    }

    @Override
    public boolean hasNext() {

        if (cursor > list.size() - 1) {
            return false;
        }

        return true;
    }


}

public class CourseAggregateImpl implements ICourseAggregate {

    private List courseList;

    public CourseAggregateImpl() {
        this.courseList = new ArrayList();
    }

    @Override
    public void add(Course course) {
        courseList.add(course);
    }

    @Override
    public void remove(Course course) {
        courseList.remove(course);
    }

    @Override
    public Iterator<Course> iterator() {
        return new IteratorImpl<>(courseList);

    }

}

public static void main(String[] args) {
    Course java = new Course("Java架構");

    Course javaBase = new Course("Java基礎");
    Course design = new Course("設計模式");

    Course ai = new Course("人工智能");

    ICourseAggregate aggregate = new CourseAggregateImpl();
    aggregate.add(java);
    aggregate.add(javaBase);
    aggregate.add(design);
    aggregate.add(ai);

    System.out.println("=========================");

    printCourse(aggregate);
    aggregate.remove(javaBase);
    System.out.println("=========================");
    printCourse(aggregate);


}


private static void printCourse(ICourseAggregate aggregate) {
    Iterator<Course> iterator = aggregate.iterator();
    while (iterator.hasNext()) {
        Course course = iterator.next();
        System.out.println("<<" + course.getName() + ">>");
    }
}

優勢:
    一、多態迭代: 爲不一樣的聚合結構提供一致的遍歷接口, 即一個迭代接口能夠訪問不一樣的彙集對象;
    二、簡化集合對象接口: 迭代器模式將集合對象自己應該提供的元素迭代接口抽取到了迭代器中, 
    使集合對象無須關心具體迭代行爲;
    三、元素迭代功能多樣化: 每一個集合對象均可以提供一個或多個不一樣的迭代器, 使的同種元素聚合結構能夠有不一樣的迭代行爲
    4 解耦迭代與集合: 迭代器模式 封裝了具體的迭代算法, 迭代算法的變化, 不會影響到集合對象的架構
缺點: 
    一、對於比較簡單的遍歷(像數組或者有序列表), 使用迭代器方式遍歷較爲繁瑣
    

源碼: ArrayList、HashMap 的迭代器方法；mybatis中的 DefaultCursor