使用Iterator

64次阅读

共计 1996 个字符，预计需要花费 5 分钟才能阅读完成。

Java 的集合类都可以使用 for each 循环，List、Set和 Queue 会迭代每个元素，Map会迭代每个 key。以 List 为例：

List<String> list = List.of("Apple", "Orange", "Pear");
for (String s : list) {System.out.println(s);
}

实际上，Java 编译器并不知道如何遍历 List。上述代码能够编译通过，只是因为编译器把for each 循环通过 Iterator 改写为了普通的 for 循环：

for (Iterator<String> it = list.iterator(); it.hasNext();) {String s = it.next();
     System.out.println(s);
}

我们把这种通过 Iterator 对象遍历集合的模式称为迭代器。

使用迭代器的好处在于，调用方总是以统一的方式遍历各种集合类型，而不必关心它们内部的存储结构。

例如，我们虽然知道 ArrayList 在内部是以数组形式存储元素，并且，它还提供了 get(int) 方法。虽然我们可以用 for 循环遍历：

for (int i=0; i<list.size(); i++) {Object value = list.get(i);
}

但是这样一来，调用方就必须知道集合的内部存储结构。并且，如果把 ArrayList 换成 LinkedList，get(int) 方法耗时会随着 index 的增加而增加。如果把 ArrayList 换成 Set，上述代码就无法编译，因为Set 内部没有索引。

用 Iterator 遍历就没有上述问题，因为 Iterator 对象是集合对象自己在内部创建的，它自己知道如何高效遍历内部的数据集合，调用方则获得了统一的代码，编译器才能把标准的 for each 循环自动转换为 Iterator 遍历。

如果我们自己编写了一个集合类，想要使用 for each 循环，只需满足以下条件：

集合类实现 Iterable 接口，该接口要求返回一个 Iterator 对象；
用 Iterator 对象迭代集合内部数据。

这里的关键在于，集合类通过调用 iterator() 方法，返回一个 Iterator 对象，这个对象必须自己知道如何遍历该集合。

一个简单的 Iterator 示例如下，它总是以倒序遍历集合：

// Iterator
import java.util.*;

public class Main {public static void main(String[] args) {ReverseList<String> rlist = new ReverseList<>();
        rlist.add("Apple");
        rlist.add("Orange");
        rlist.add("Pear");
        for (String s : rlist) {System.out.println(s);
        }
    }
}

class ReverseList<T> implements Iterable<T> {private List<T> list = new ArrayList<>();

    public void add(T t) {list.add(t);
    }

    @Override
    public Iterator<T> iterator() {return new ReverseIterator(list.size());
    }

    class ReverseIterator implements Iterator<T> {int index;

        ReverseIterator(int index) {this.index = index;
        }

        @Override
        public boolean hasNext() {return index > 0;
        }

        @Override
        public T next() {
            index--;
            return ReverseList.this.list.get(index);
        }
    }
}

虽然 ReverseList 和ReverseIterator的实现类稍微比较复杂，但是，注意到这是底层集合库，只需编写一次。而调用方则完全按 for each 循环编写代码，根本不需要知道集合内部的存储逻辑和遍历逻辑。

在编写 Iterator 的时候，我们通常可以用一个内部类来实现 Iterator 接口，这个内部类可以直接访问对应的外部类的所有字段和方法。例如，上述代码中，内部类 ReverseIterator 可以用 ReverseList.this 获得当前外部类的 this 引用，然后，通过这个 this 引用就可以访问 ReverseList 的所有字段和方法。

Iterator是一种抽象的数据访问模型。使用 Iterator 模式进行迭代的好处有：