设计模式-迭代器模式

一、迭代器模式(行为型模式)
1.定义
迭代器模式(Iterator Pattern)又称为游标者模式(Cursor Pattern)。迭代器模式提供了一种顺序访问集合/容器中对象元素的方法，不用关心集合内部元素的组成结构，又无需暴露集合中内部的表示。
2.迭代器模式角色
**(1).抽象集合（Aggregate）角色：**定义存储、添加、删除对象以及创建迭代器对象的接口。
**(2).具体集合（ConcreteAggregate）角色：**实现抽象集合类，返回一个具体迭代器的实例。
**(3).抽象迭代器（Iterator）角色：**定义访问和遍历集合元素的接口，通常包含 hasNext()、first()、next() 等方法。
**(4).具体迭代器（ConcreteIterator）角色：**实现抽象迭代器接口中所定义的方法，完成对集合对象的遍历，记录遍历的当前位置。
3.代码实现方式
(1).创建一个抽象集合角色，定义存储、添加、删除对象的方法，定义一个创建迭代器的方法。
(2).创建一个具体集合角色，实现抽象集合角色，重写所有方法。
(3).创建一个抽象迭代器角色，定义访问和遍历集合元素的方法，通常由hasNext()、first()、next()方法
(4).创建一个具体迭代器角色，实现抽象迭代器，重写方法。
4.代码实现
(1).具体代码

package com.tw.designPattern.iterator;

/**
 * 抽象集合角色
 */
public interface Aggregate<T> {

    void add(Object obj);

    void remove(Object obj);

    Iterator getIterator();

}

package com.tw.designPattern.iterator;

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

/**
 * 具体集合角色
 */
public class ConcreteAggregate implements Aggregate{

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

    @Override
    public void add(Object obj) {
        Runtime.getRuntime();
        list.add(obj);
    }

    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }

    @Override
    public Iterator getIterator() {
        return new ConcreteIterator(list);
    }
}

package com.tw.designPattern.iterator;

/**
 * 抽象迭代器角色
 */
public interface Iterator<T> {

    Object first();

    Object next();

    boolean hasNext();
}

package com.tw.designPattern.iterator;

import java.util.List;

/**
 * 具体迭代器角色
 */
public class ConcreteIterator<T> implements Iterator<T>{

    private List<T> list;

    private int index = -1;

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

    @Override
    public T first() {
        index = 0;
        T o = list.get(index);
        return o;
    }

    @Override
    public T next() {
        T t = null;
        if (hasNext()){
            t = list.get(++index);
        }
        return t;
    }

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

package com.tw.designPattern.iterator;

import java.io.*;

public class IteratorTest implements Serializable{


    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("第一个");
        aggregate.add("第二个");
        aggregate.add("第三个");
        aggregate.add("第四个");
        Iterator iterator = aggregate.getIterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next.toString() + "\t");
        }
        Object first = iterator.first();
        System.out.println("First:" + first.toString());


    }
}

测试结果

第一个	
第二个	
第三个	
第四个	
First:第一个

5.优缺点
(1).优点
(1-1).访问一个集合对象的内容而无须暴露它的内部表示。
(1-2).遍历任务交由迭代器完成，这简化了集合类。
(1-3).它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
(1-4).增加新的集合类和迭代器类都很方便，无须修改原有代码。
(1-5).封装性良好，为遍历不同的集合结构提供一个统一的接口。
(2).缺点
(2-1).增加了类的个数，这在一定程度上增加了系统的复杂性。
6.应用场景
(1).当需要为聚合对象提供多种遍历方式时。
(2).当需要为遍历不同的聚合结构提供一个统一的接口时。
(3).当访问一个聚合对象的内容而无须暴露其内部细节的表示时。
注：迭代器模式在开发中很少用，Java集合中已经给我们提供了很全面了，示例代码中其实有点取巧了，ConcreteAggregate (具体集合角色)里面维护的是一个List，其实就是为了方便操作，不然你还得记录下标，动态扩容等等一系列的操作，只要能理解这个模式就可以了，有兴趣的小伙伴可以看下Java的List的源码，它里面维护就是Object[]数组。
注：内容参考网络上各种资料，还有一些本人的理解和思想，仅为了学习记录和分享一下自己所学之处，如有不足的地方麻烦大牛指出，如有侵权的地方，请联系删除，谢谢