设计模式——迭代器模式

场景引入

在数据结构中，我们知道：对于顺序存储和非顺序存储，他们遍历元素的方式是不一样的。既然遍历的方式不同，那么就有不同的迭代元素的方式。那么 如果我把迭代数据的方式抽取出来，作为一个新的类或者接口，那么针对每一种存储结构，他都应该实现这个接口，在里面实现自己迭代数据的方式。这样使我们不用去了解底层的实现原理，而可以把不同情况下的迭代看成是一样的。

模式优点

1. 访问一个聚合对象的内容而无须暴露它的内部表示。
2. 遍历任务交由迭代器完成，这简化了聚合类。
3. 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
4. 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
5. 封装性良好，为遍历不同的聚合结构提供一个统一的接口。

模式缺点

增加了一个新的类，这样会增加系统的复杂性

代码实现

Collection_ interface

public interface Collection_ {
    
    void add(Object o);
    
    Boolean remove(Object o);
    
    Iterator_ iterator();
}

Iterator_ interface

//提供的统一迭代器接口
public interface Iterator_ {
    Boolean hasNext();

    Object next();
}

ArrayList_.java

public class ArrayList_ implements Collection_{
    private int len = 10;
    private int used = 0;
    Object[] elems = new Object[len];

    @Override
    public void add(Object o) {
        if(used < len ){
            elems[used++] = o;
        }else{
            elems = new Object[len * 2];
            elems = Arrays.copyOfRange(elems, 0, len);
            elems[used++] = o;
        }
    }

    @Override
    public Boolean remove(Object o) {
        if(used <= 0){
            return false;
        }else{
            used--;
            return true;
        }

    }

    @Override
    public Iterator_ iterator() {
        return  new ArrayList_.Itr();
    }
    //使用内部类实现其结构的迭代元素的方式
    private class Itr implements Iterator_ {
        private int cursor = 0;

        Itr() {
        }

        @Override
        public Boolean hasNext() {
            return cursor != used;
        }

        @Override
        public Object next() {
            return elems[cursor++];
        }
    }

}

Test.java

public class Test {
    public static void main(String[] args) {
        ArrayList_ list_ = new ArrayList_();
        list_.add(12);
        list_.add(14);
        list_.add(15);
        Iterator_ iterator = list_.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}