【设计模式】迭代器模式

一、介绍

1）迭代器模式（ lterator Pattern）是常用的设计模式，属于行为型模式
2）如果我们的集合元素是用不同的方式实现的，有数组，还有java的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。
3）迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。

二、实现

MyIterator

package com.swust.java.行为型模式.迭代器模式;

/**
 * 自定义的迭代器接口
 */
public interface MyIterator {
    void first();
    void next();
    boolean hasNext();

    boolean isFirst();
    boolean isLast();

    Object getCurrentObj(); // 获取当前游标指向的对象
}

ConcreteMyAggregate

package com.swust.java.行为型模式.迭代器模式;

import java.util.ArrayList;
import java.util.List;

/**
 * 自定义的聚合类
 */
public class ConcreteMyAggregate {

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

    public ConcreteMyAggregate() {
    }

    public ConcreteMyAggregate(List<Object> list) {
        this.list = list;
    }

    public void addObject(Object obj){
        this.list.add(obj);
    }

    public void removeObject(Object obj){
        this.list.remove(obj);
    }

    public List<Object> getList() {
        return list;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }

    /**
     * 获取迭代器
     */
    public MyIterator createIterator(){
        return new ConcreteIterator();
    }

    /**
     * 使用内部类定义迭代器
     * 可以直接使用外部类的属性
     */
    private class ConcreteIterator implements MyIterator{

        private int cursor; // 定义游标,用于记录遍历时的位置

        @Override
        public void first() {
            cursor = 0;
        }

        @Override
        public void next() {
            if (cursor < list.size()){
                cursor++;
            }
        }

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

        @Override
        public boolean isFirst() {
            return cursor == 0 ? true : false;
        }

        @Override
        public boolean isLast() {
            return cursor == (list.size()-1) ? true : false;
        }

        @Override
        public Object getCurrentObj() {
            return list.get(cursor);
        }
    }
}

Client

package com.swust.java.行为型模式.迭代器模式;

public class Client {

    public static void main(String[] args) {
        ConcreteMyAggregate cma = new ConcreteMyAggregate();
        cma.addObject("aa");
        cma.addObject("bb");
        cma.addObject("cc");
        cma.addObject("dd");
        MyIterator iterator = cma.createIterator();

        while (iterator.hasNext()){
            System.out.println(iterator.getCurrentObj());
            iterator.next();
        }
    }
}

运行结果

aa
bb
cc
dd

三、注意事项

优点
1）它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
2）迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
3）在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足 “开闭原则” 的要求。
缺点
1）增加了类的个数，这在一定程度上增加了系统的复杂性。