Iterator 迭代器的那些事

在帮助文档的第一行会看到这么一行字

• All Superinterfaces

• 父接口  

Collection接口

所以Collection接口 实现了 Interface Iterable<T> 接口

在Iterable接口中又提到

• 实现此接口允许对象成为增强型 for语句（有时称为“for-each loop”语句）的目标

• 也就是俗称的增强for循环

List接口

接下来看Collection接口中的List接口

List有两个实现类 一个是ArrayList 另一个是LinkedList

Iterator迭代器

List的方法中具体看迭代器的方法

• • Iterator<E>	iterator​()	以正确的顺序返回该列表中的元素的迭代器。

第一个是返回值类型 第二个是方法名及其需要的参数

也就是说 iterator迭代器    返回的是   一个元素迭代器

• • boolean	hasNext​()	如果迭代具有更多元素，则返回 true 。
    E	next​()	返回迭代中的下一个元素。
    default void	remove​()	从底层集合中删除此迭代器返回的最后一个元素（可选操作）。

 通过帮助文档我们知道，Iterator迭代器对象的常用方法有这三个，遍历的时候使用前两个即可

package myCollection.test02;

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

public class ListDemo {
    public static void main(String[] args) {
//        创建集合对象
        List<String> list=new ArrayList<String>();

//        添加元素
        list.add("today");
        list.add("is");
        list.add("a");
        list.add("nice");
        list.add("day");

//        通过Arraylist中的iterator()方法获取迭代器对象
        Iterator<String> it = list.iterator();

//        遍历集合
//        boolean	hasNext()	如果迭代具有更多元素，则返回 true
        while (it.hasNext()){
//            E next() 返回迭代中的下一个元素。  
            String s = it.next();
            System.out.println(s);
        }
    }
}

listIterator列表迭代器

• • ListIterator<E>	listIterator​()	返回列表中的列表迭代器（按适当的顺序）。

 有过之前的铺垫，对列表迭代器也不难理解，他也是通过ArrayList的listIterator（）方法去获取迭代器对象的。

下面来看一下他的常用方法

• • void	add​(E e)	将指定的元素插入列表（可选操作）。
    boolean	hasNext​()	如果此列表迭代器在向前方向遍历列表时具有更多元素，则返回 true 。
    boolean	hasPrevious​()	如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回 true 。
    E	next​()	返回列表中的下一个元素，并且前进光标位置。
    int	nextIndex​()	返回由后续调用返回的元素的索引 next() 。
    E	previous​()	返回列表中的上一个元素，并向后移动光标位置。
    int	previousIndex​()	返回由后续调用返回的元素的索引 previous() 。
    void	remove​()	从列表中删除 next()或 previous() （可选操作）返回的最后一个元素。

 

• 用于允许程序员沿任一方向遍历列表的列表的迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

与Iterator（）不同的是，listIterator（）可以在元素遍历的时候进行增删，不会报出并发修改异常的错误。

//以下方法是ArrayList中的
public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }
————————————————————————————————————————————————————————————————————————
//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;

        // prevent creating a synthetic constructor
        Itr() {}

        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];
        }

        


        final void checkForComodification() {
//对修改次数 和 预期修改次数 进行判断 如果不同 抛出异常
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

——————————————————————————————————————————————————————————

 private class ListItr extends Itr implements ListIterator<E> {
        ListItr(int index) {
            super();
            cursor = index;
        }

        public boolean hasPrevious() {
            return cursor != 0;
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor - 1;
        }

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

        public void set(E e) {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.set(lastRet, e);
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }


        public void add(E e) {
//添加元素的时候 调用内部类Itr中的方法，因为下面的try catch 所以不会出现expectedModCount ！= modCount这一情况
            checkForComodification();

            try {
                int i = cursor;
                ArrayList.this.add(i, e);
                cursor = i + 1;
                lastRet = -1;
//listIterator中将修改次数赋值给预期修改次数，也就不会在添加的时候报错并发修改异常
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    }

不过，如果不是特别需要，不经常使用列表迭代器，普通迭代器除了不能在遍历的时候增删，其他杠杠的。

好啦，本期迭代器相关知识分享完毕，咱们江湖见啦~