public abstract class Aggregate {
    /**
     * 工廠方法,，創(chuàng)建相應(yīng)迭代子對(duì)象的接口
     */
    public abstract Iterator createIterator();
}

public class ConcreteAggregate extends Aggregate {
    
    private Object[] objArray = null;
    /**
     * 構(gòu)造方法，傳入聚合對(duì)象的具體內(nèi)容
     */
    public ConcreteAggregate(Object[] objArray){
        this.objArray = objArray;
    }
    
    @Override
    public Iterator createIterator() {
        
        return new ConcreteIterator(this);
    }
    /**
     * 取值方法：向外界提供聚集元素
     */
    public Object getElement(int index){
        
        if(index < objArray.length){
            return objArray[index];
        }else{
            return null;
        }
    }
    /**
     * 取值方法：向外界提供聚集的大小
     */
    public int size(){
        return objArray.length;
    }
}

public interface Iterator {
    /**
     * 迭代方法：移動(dòng)到第一個(gè)元素
     */
    public void first();
    /**
     * 迭代方法：移動(dòng)到下一個(gè)元素
     */
    public void next();
    /**
     * 迭代方法：是否為最后一個(gè)元素
     */
    public boolean isDone();
    /**
     * 迭代方法：返還當(dāng)前元素
     */
    public Object currentItem();
}

public class ConcreteIterator implements Iterator {
    //持有被迭代的具體的聚合對(duì)象
    private ConcreteAggregate agg;
    //內(nèi)部索引,，記錄當(dāng)前迭代到的索引位置
    private int index = 0;
    //記錄當(dāng)前聚集對(duì)象的大小
    private int size = 0;
    
    public ConcreteIterator(ConcreteAggregate agg){
        this.agg = agg;
        this.size = agg.size();
        index = 0;
    }
    /**
     * 迭代方法：返還當(dāng)前元素
     */
    @Override
    public Object currentItem() {
        return agg.getElement(index);
    }
    /**
     * 迭代方法：移動(dòng)到第一個(gè)元素
     */
    @Override
    public void first() {
        
        index = 0;
    }
    /**
     * 迭代方法：是否為最后一個(gè)元素
     */
    @Override
    public boolean isDone() {
        return (index >= size);
    }
    /**
     * 迭代方法：移動(dòng)到下一個(gè)元素
     */
    @Override
    public void next() {

        if(index < size)
        {
            index ++;
        }
    }

}

public class Client {

    public void operation(){
        Object[] objArray = {"One","Two","Three","Four","Five","Six"};
        //創(chuàng)建聚合對(duì)象
        Aggregate agg = new ConcreteAggregate(objArray);
        //循環(huán)輸出聚合對(duì)象中的值
        Iterator it = agg.createIterator();
        while(!it.isDone()){
            System.out.println(it.currentItem());
            it.next();
        }
    }
    public static void main(String[] args) {
        
        Client client = new Client();
        client.operation();
    }

}

public abstract class Aggregate {
    /**
     * 工廠方法,，創(chuàng)建相應(yīng)迭代子對(duì)象的接口
     */
    public abstract Iterator createIterator();
}

public interface Iterator {
    /**
     * 迭代方法：移動(dòng)到第一個(gè)元素
     */
    public void first();
    /**
     * 迭代方法：移動(dòng)到下一個(gè)元素
     */
    public void next();
    /**
     * 迭代方法：是否為最后一個(gè)元素
     */
    public boolean isDone();
    /**
     * 迭代方法：返還當(dāng)前元素
     */
    public Object currentItem();
}

public class ConcreteAggregate extends Aggregate {
    
    private Object[] objArray = null;
    /**
     * 構(gòu)造方法，傳入聚合對(duì)象的具體內(nèi)容
     */
    public ConcreteAggregate(Object[] objArray){
        this.objArray = objArray;
    }
    
    @Override
    public Iterator createIterator() {

        return new ConcreteIterator();
    }
    /**
     * 內(nèi)部成員類,，具體迭代子類
     */
    private class ConcreteIterator implements Iterator
    {
        //內(nèi)部索引,，記錄當(dāng)前迭代到的索引位置
        private int index = 0;
        //記錄當(dāng)前聚集對(duì)象的大小
        private int size = 0;
        /**
         * 構(gòu)造函數(shù)
         */
        public ConcreteIterator(){
            
            this.size = objArray.length;
            index = 0;
        }
        /**
         * 迭代方法：返還當(dāng)前元素
         */
        @Override
        public Object currentItem() {
            return objArray[index];
        }
        /**
         * 迭代方法：移動(dòng)到第一個(gè)元素
         */
        @Override
        public void first() {
            
            index = 0;
        }
        /**
         * 迭代方法：是否為最后一個(gè)元素
         */
        @Override
        public boolean isDone() {
            return (index >= size);
        }
        /**
         * 迭代方法：移動(dòng)到下一個(gè)元素
         */
        @Override
        public void next() {

            if(index < size)
            {
                index ++;
            }
        }
    }
}

public class Client {

    public void operation(){
        Object[] objArray = {"One","Two","Three","Four","Five","Six"};
        //創(chuàng)建聚合對(duì)象
        Aggregate agg = new ConcreteAggregate(objArray);
        //循環(huán)輸出聚合對(duì)象中的值
        Iterator it = agg.createIterator();
        while(!it.isDone()){
            System.out.println(it.currentItem());
            it.next();
        }
    }
    public static void main(String[] args) {
        
        Client client = new Client();
        client.operation();
    }

}

    private class Itr implements Iterator<E> {
        /**
         * Index of element to be returned by subsequent call to next.
         */
        int cursor = 0;

        /**
         * Index of element returned by most recent call to next or
         * previous.  Reset to -1 if this element is deleted by a call
         * to remove.
         */
        int lastRet = -1;

        /**
         * The modCount value that the iterator believes that the backing
         * List should have.  If this expectation is violated, the iterator
         * has detected concurrent modification.
         */
        int expectedModCount = modCount;

        public boolean hasNext() {
                return cursor != size();
        }

        public E next() {
                checkForComodification();
            try {
            E next = get(cursor);
            lastRet = cursor++;
            return next;
            } catch (IndexOutOfBoundsException e) {
            checkForComodification();
            throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet == -1)
            throw new IllegalStateException();
                checkForComodification();

            try {
            AbstractList.this.remove(lastRet);
            if (lastRet < cursor)
                cursor--;
            lastRet = -1;
            expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
            throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        }
    }