迭代器模式---简易代码实现和类图

迭代器模式

定义：

提供了一种方法，顺序访问一个集合对象中的各个元素，而又不暴露该对象的内部表示。

类型：

行为型

适用场景：

访问一个集合对象的内容而无需暴露它的内部表示。

为遍历不同的集合结构提供一个统一的接口。

优点：

分离了集合对象的遍历行为。

缺点：

类的个数成对增加。

迭代器模式和访问者模式

都是迭代的访问一个集合中各个元素。访问者扩展开放对象的操作，迭代器扩展开放对象的种类。

代码：

//集合的接口
public interface Aggregate {
    public void add(int a);
    public void remove(int b);
    public Iterator getIterator();

}

//集合的实现
public class ConcertelAggregate implements Aggregate{
    private List<Integer> list=new ArrayList<>();
    @Override
    public void add(int a) {
        list.add(a);
    }

    @Override
    public void remove(int b) {
     list.remove(b);
    }

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

//迭代器接口
public interface Iterator {
    public int first();
    public int next();
    public boolean hasNext();
}

//迭代器实现
public class ConcerteIterator implements Iterator {
    //存储数据
    private  List<Integer> list=null;
    //下标
    private int index;

    public ConcerteIterator(List<Integer> list) {
        this.list = list;
    }

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

    @Override
    public int next() {
        Integer temp=null;
        if(this.hasNext()){
            temp=list.get(index);
            index++;
        }
        return temp;
    }

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

//测试类
public class testIterator {
    public static void main(String[] args) {
        Aggregate aggregate=new ConcertelAggregate();
        aggregate.add(1);
        aggregate.add(2);
        aggregate.add(3);
        Iterator iter=aggregate.getIterator();
        while(iter.hasNext()){
            int k=iter.next();
            System.out.println(k);
        }
        System.out.println(iter.first());
    }
}

类图：