深入理解23种设计模式(15) -- 迭代器模式

介绍

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

• Iterator：迭代器定义访问和遍历元素的接口。
• ConcreteIterator：具体迭代器实现迭代器接口，对该聚合遍历时跟踪当前位置。
• Aggregate：聚合定义创建相应迭代器对象的接口。
• ConcreteAggregate：具体聚合实现创建相应迭代器的接口，该操作返回 ConcreteIterator 的一个适当的实例。

---

JDK迭代器实现

Java中List集合实现类 迭代器模式

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("123");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

源码如下

 public Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}
		
		/**
		 * 判断元素是否存在
		 **/
        public boolean hasNext() {
            return cursor != size;
        }
		
		//获取下一个元素
        @SuppressWarnings("unchecked")
        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];
        }

案例

• 添加专业，进行遍历

1. 实体类

@Data
public class Department {


    private String name;

    private String desc;


    public Department(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
}

2. 添加 College 接口

public interface College {

    /**
     * 获取名称
     * @return
     */
    public String getName();

    /**
     * 添加院系
     * @param name
     * @param desc
     */
    public void addDepartment(String name,String desc);

    /**
     * 遍历
     * @return
     */
    public Iterator createIterator();

}

2. 实现 College 接口

public class InfoCollege implements College{


    List<Department> departmentList;

    int numOfDepartment = 0;


    public InfoCollege() {
        departmentList = new ArrayList<>();
    }

    @Override
    public String getName() {
        return "信息工程学院";
    }

    @Override
    public void addDepartment(String name, String desc) {
        Department department = new Department(name,desc);
        departmentList.add(department);
    }

    @Override
    public Iterator createIterator() {
        return new InfoColleageIterator(departmentList);
    }
}

4. 重写迭代器

public class InfoColleageIterator implements Iterator {

    List<Department> departmentList;

    int index = -1;

    public InfoColleageIterator(List<Department> departmentList) {
        this.departmentList = departmentList;
    }

    @Override
    public boolean hasNext() {
        if(index >= departmentList.size() - 1){
            return false;
        }else{
            index += 1;
            return true;
        }
    }

    @Override
    public Object next() {
        return departmentList.get(index);
    }


    @Override
    public void remove() {

    }
}

5. 测试Client

public class Client {

    public static void main(String[] args) {
        College college = new InfoCollege();
        college.addDepartment("11","11");
        college.addDepartment("22","22");
        Iterator it = college.createIterator();
        while (it.hasNext()) {

            System.out.println( it.next());
        }

    }
}

迭代器优点和缺点

优点：

1）它支持以不同的方式遍历一个聚合对象。
2）迭代器简化了聚合类。
3）在同一个聚合上可以有多个遍历。 
4）在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。 

缺点：

 1）由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

---

github Demo地址 : ～～～传送门～～～

个人博客地址：http://blog.yanxiaolong.cn/