Iterator 迭代器模式

简介：

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

模式结构：

一、Collection:抽象集合接口
二、Iterator:抽象迭代器接口
三、Arraylist、HashSet:具体集合类，经过iterator()返回具体的迭代器对象
四、ArrayIterator、HashIterator:具体的迭代器

模式实例：

一、Collection：抽象集合接口

public interface Collection<E> {
    public void add(E o);
 int size();
 Iterator_ iterator();
}

二、Arraylist_：实现Collection接口的集合类

/**
 * 相比与数组，这个容器不用考虑边界问题，能够动态扩展
 */
public class Arraylist_<E> implements Collection<E> {
    E[] objects = (E[])new Object[10];
 //objects中下一个空的位置在哪儿，或者说目前容器中有多少个元素
 private int index = 0;
 public void add(E o) {
        if(index == objects.length){
            E[] newObjects = (E[])new Object[objects.length * 2];
 System.arraycopy(objects,0,newObjects,0,objects.length);
 objects = newObjects;
 }
        objects[index] = o;
 index++;
 }
    public int size(){return index;}
    @Override
 public Iterator_ iterator() {
        return new ArraylistIterator();
 }
    private class ArraylistIterator<E> implements Iterator_<E> {
        private int currentIndex = 0;
 @Override
 public boolean hasNext() {
            if(currentIndex >= index) {
                return false;
 }
            return true;
 }
        @Override
 public E next() {
            E o = (E) objects[currentIndex];
 currentIndex++;
 return o;
 }
    }
}

三、Iterator_：迭代器接口

public interface Iterator_<E> {
    boolean hasNext();
 E next();
}

四、Main: 测试

public class Main {
    public static void main(String[] args) {
        Collection<String> list = new Arraylist_<String>();
 for(int i = 0; i<15; i++) {
            list.add(new String("s"+i));
 }
        System.out.println(list.size());
 Iterator_<String> it = list.iterator();
 while (it.hasNext()){
            String o = it.next();
 System.out.println(o);
 }
    }
}