Java源码解析-迭代器

ゝ一纸荒年。 2022-05-31 05:54 157阅读 0赞

# 自己写一个迭代器 #

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