十七、Java集合类-迭代器.md

📖 青空的霞光B站课程

📅 2024年4月17日

迭代器

⭐ 集合类都是支持foreach语句的，但是虽然你在代码里面写的是foreach写法实际上是语法糖，但是在编译后就会切换成迭代器的语法

//foreach语法
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
        for(String s : list){
            System.out.println(s);
        }
    }

//编译后
    public static void main(String[] args) {
        List<String> list = new ArrayList(Arrays.asList("A", "B", "C"));
        Iterator var2 = list.iterator(); //使用了list的迭代器	

        while(var2.hasNext()) {
            String s = (String)var2.next();
            System.out.println(s);
        }

1️⃣ 自己来解读一下这个啥意思，List的父类Collection继承了可迭代接口 Iterable ，里面有一个Itertor的迭代器方法需要实现

public interface Collection<E> extends Iterable<E> //继承

public interface Iterable<T> {
    /**
     * Returns an iterator over elements of type {@code T}.
     *
     * @return an Iterator.
     */
    Iterator<T> iterator(); //迭代器方法
}

2️⃣ 可以看看Iterator迭代器内的方法

public interface Iterator<E> {
    //看看是否还有下一个元素，放回boolean值
    boolean hasNext();

    //遍历当前元素，并将下一个元素作为待遍历元素
    E next();

    //移除上一个被遍历的元素（某些集合不支持这种操作）
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    //对剩下的元素进行自定义遍历操作
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

3️⃣ 在回头去看看编译后的代码，这样就好理解了

//编译后
    public static void main(String[] args) {
        List<String> list = new ArrayList(Arrays.asList("A", "B", "C"));
        Iterator var2 = list.iterator(); //使用了list的迭代器	

        while(var2.hasNext()) { //去调用Itertor迭代器hasNext方法，查看下一个元素有就返回true
            String s = (String)var2.next(); //遍历当前的元素
            System.out.println(s); //打印当前元素
        }

⭐ 迭代器的运作机制大概是

一个新的迭代器就像上面这样，默认有一个指向集合中第一个元素的指针：

每一次next操作，都会将指针后移一位，直到完成每一个元素的遍历，此时再调用next将不能再得到下一个元素。至于为什么要这样设计，是因为集合类的实现方案有很多，可能是链式存储，也有可能是数组存储，不同的实现有着不同的遍历方式，而迭代器则可以将多种多样不同的集合类遍历方式进行统一，只需要各个集合类根据自己的情况进行对应实现就行了

1️⃣ 在不同的集合类型中，实现next的方法也是不一样的可以看看

//ArrayList直接访问下标
public E next() {
    ...
    cursor = i + 1;   //移动指针
    return (E) elementData[lastRet = i];  //直接返回指针所指元素
}


//LinkedList不断向后寻找终点

public E next() {
    ...
    next = next.next;   //向后继续寻找结点
    nextIndex++;
    return lastReturned.item;  //返回结点内部存放的元素
}

2️⃣ 但是无论内部是如何实现的，我们在使用的时候直接使用迭代器就好了，使用方法都是一样的

public static void main(String[] args) {
    List<String> list = Arrays.asList("A", "B", "C");
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {    //每次循环一定要判断是否还有元素剩余
        System.out.println(iterator.next());  //如果有就可以继续获取到下一个元素
    }
}

⭐ 迭代器使用时一次性的，也就是一个迭代器对象，只能使用一次，如果想要再次遍历就需要在去生成一个迭代器对象，所以为了简便就直接使用foreach就好了

    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C");
        for (String s : list) {   
            System.out.println(s);  
        }
    }

3️⃣ 在JAVA8中提供了一个支持Lambda表达式的forEach方法，这个方法需要接受一个Consumer对象(可以去泛型笔记看看函数式接口)，

    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C");
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
    }

//缩减成lambda表达式
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C");
        list.forEach(s -> System.out.println(s));
    }

//还可以继续替换成方法引用
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C");
        list.forEach(System.out::println);
    }

但是它本质也是使用的foreach循环来遍历打印，这个方法实在Iterable接口中定义的

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {   //foreach语法遍历每一个元素
        action.accept(t);   //调用Consumer的accept来对每一个元素进行消费
    }
}

⭐ Iterator是继承自Iterable ，看一下它的源代码

//注意这个接口是集合接口的父接口，不要跟之前的迭代器接口搞混了
public interface Iterable<T> {
    //生成当前集合的迭代器，在Collection接口中重复定义了一次
    Iterator<T> iterator();

    //Java8新增方法，因为是在顶层接口中定义的，因此所有的集合类都有这个方法
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    //这个方法会在多线程部分中进行介绍，暂时不做讲解
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

1️⃣ Iterable提供了迭代器的生成方法，实际上只要是实现了迭代器接口的类（我们自己写的都行），都可以使用foreach语法

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
//        test.forEach(System.out::println); 
        //或则
        for (String s : test){
            System.out.println(s);
        }
    }
    public static class Test implements Iterable<String>{ //写一个类实现Iterable接口

        @Override
        public Iterator<String> iterator() { //需要重写iterator方法
            return new Iterator<String>() { //创建一个迭代器对象，需要通过内部类来实现它的两个方法
                @Override
                public boolean hasNext() { //表示一直会返回true,也就是告诉程序我这个里面会一直有数据
                    return true;
                }

                @Override
                public String next() { //返回当前数据
                    return "TestIng...";
                }
            };
        }
    }
}

⭐ ListIterator这个迭代器是针对List的强化版本，增加了很多操作，List是有序集合，使用他还支持两种方向的遍历，从后往前，从前往后

public interface ListIterator<E> extends Iterator<E> {
    //原本就有的
    boolean hasNext();

    //原本就有的
    E next();

    //查看前面是否有已经遍历的元素
    boolean hasPrevious();

    //跟next相反，这里是倒着往回遍历
    E previous();

    //返回下一个待遍历元素的下标
    int nextIndex();

    //返回上一个已遍历元素的下标
    int previousIndex();

    //原本就有的
    void remove();

    //将上一个已遍历元素修改为新的元素
    void set(E e);

    //在遍历过程中，插入新的元素到当前待遍历元素之前
    void add(E e);
}

1️⃣测试一下

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
        ListIterator<String> iterator = list.listIterator();
        iterator.next();   //此时得到A
        iterator.set("X");  //将A原本位置的上的元素设定为成新的
        System.out.println(list);
        iterator.remove(); //会删除上一个遍历
        System.out.println(list);
    }

//输出:
[X, B, C]
[B, C]