Java源码解析-迭代器

自己写一个迭代器

/**
 * 迭代器接口
 */
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();
        }
    }