迭代器模式 | 易学教程

又称为游标模式, 它提供一种顺序集合、容器对象元素的方法, 而又无须暴露集合内部表示。
特征: 抽离集合对象迭代行为到迭代器中, 提供一致访问接口
属于行为型模式

适用场景:
1、访问一个集合对象的内容而无须暴露它的内部表示
2、为遍历不同的集合结构提供一个统一的访问接口

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() + ">>");
    }
}

优点:
   1、多态迭代: 为不同的聚合结构提供一致的遍历接口, 即一个迭代接口可以访问不同的聚集对象;
   2、简化集合对象接口: 迭代器模式将集合对象本身应该提供的元素迭代接口抽取到了迭代器中,
   使集合对象无须关心具体迭代行为;
   3、元素迭代功能多样化: 每个集合对象都可以提供一个或多个不同的迭代器, 使的同种元素聚合结构可以有不同的迭代行为
   4 解耦迭代与集合: 迭代器模式封装了具体的迭代算法, 迭代算法的变化, 不会影响到集合对象的架构
缺点:
   1、对于比较简单的遍历(像数组或者有序列表), 使用迭代器方式遍历较为繁琐

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

来源：oschina

链接：https://my.oschina.net/u/2954646/blog/3196445

标签

cursor

迭代器

list

iterator

aggregate