自己寫一個迭代器

/**
 * 迭代器介面
 */
interface Selector {
    boolean end();

    Object current();

    void next();
}

public class Sequence {
    private Object[] items; // 內部持有一個Object陣列

    private int next = 0;

    /**
     * 初始化Object陣列
     * @param size
     */
    public Sequence(int size) {
        items = new
 
 Object[size];
    }

    public void add(Object item) {
        if (next < items.length) {
            items[next++] = item;
        }
    }

    public Selector getSelector() {
        return new SequenceSelector();
    }

    public Selector getReverseSelector() {
        return new ReverseSelector();
    }

    /**
     * 實現了迭代器介面的內部類
     */
 

    private class SequenceSelector implements Selector {

        private int i = 0;

        public boolean end() {
            return i == items.length;
        }

        public Object current() {
            return items[i];
        }

        public void next() {
            if (i < items.length) {
                i++;
            }
        }

    }// end inner class
 


    private class ReverseSelector implements Selector {

        private int i = items.length - 1;

        @Override
        public boolean end() {
            return i < 0;
        }

        @Override
        public Object current() {
            return items[i];
        }

        @Override
        public void next() {
            if (i >= 0) {
                i--;
            }
        }
    }


    public static void main(String[] args) {
        Sequence sequence = new Sequence(10);

        for (int i = 0; i < 10; i++) {
            sequence.add(String.format("我是第%d個元素", i + 1));
        }
        Selector selector = sequence.getSelector();
        while (!selector.end()) {
            System.out.println((String.format("當前物件是：%s", selector.current())));
            selector.next();
        }

        // 反方向遍歷序列
        Selector reverseSelector = sequence.getReverseSelector();
        while (!reverseSelector.end()) {
            System.out.println((String.format("當前物件是：%s", reverseSelector.current())));
            reverseSelector.next();
        }
    }// end main method
}

輸出：

當前物件是：我是第1個元素
當前物件是：我是第2個元素
當前物件是：我是第3個元素
當前物件是：我是第4個元素
當前物件是：我是第5個元素
當前物件是：我是第6個元素
當前物件是：我是第7個元素
當前物件是：我是第8個元素
當前物件是：我是第9個元素
當前物件是：我是第10個元素
當前物件是：我是第10個元素
當前物件是：我是第9個元素
當前物件是：我是第8個元素
當前物件是：我是第7個元素
當前物件是：我是第6個元素
當前物件是：我是第5個元素
當前物件是：我是第4個元素
當前物件是：我是第3個元素
當前物件是：我是第2個元素
當前物件是：我是第1個元素

ArrayList的迭代器

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

/**
 * Created by lerry on 2018/2/9.
 * @author lerry
 */
public class ListIteratorTry {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10; i++) {
            list.add(String.format("第%d個元素", i + 1));
        }

        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(String.format("列印：%s", iterator.next()));
        }
    }
}

我們檢視ArrayList的原始碼，發現：

public Iterator<E> iterator() {
        return new Itr();
    }

Itr類是ArrayList的一個內部類

private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

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

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

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