Iterator

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对象遍历集合的模式称为迭代器。好处在于，调用方总是以统一的方式遍历各种集合类型，而不必关系它们内部的存储结构。因为Iterator对象是集合对象自己在内部创建的，它自己知道如何高效遍历内部的数据集合，调用方则获得了统一的代码，编译器才能把标准的for each循环自动转换为Iterator遍历。

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

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

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

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

import java.util.*;
import java.util.function.Consumer;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> {//集合类实现Iterable接口private List<T> list = new ArrayList<>();public void add(T t) {list.add(t);}@Overridepublic Iterator<T> iterator() {//返回一个Iterator对象return new ReverseIterator(list.size());}class ReverseIterator implements Iterator<T> {//内部类实现Iterator接口int index;ReverseIterator(int index) {this.index = index;}@Overridepublic boolean hasNext() {return index > 0;}@Overridepublic T next() {index--;return ReverseList.this.list.get(index);}}
}

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

Collections

Collections是JDK提供的工具类，同样位于java.util包中。它提供了一系列静态方法，能更方便地操作各种集合。注意Collections结尾多了一个s，不是Collection！

创建空集合

Collections提供了一系列方法来创建一个单元素集合：

创建一个元素的List：List<T> singletonList(T o)
创建一个元素的Map：Map<K, V> singletonMap(K key, V value)
创建一个元素的Set：Set<T> singleton(T o)

要注意到返回的空集合是不可变集合，无法向其中添加或删除元素。

此外，也可以用各个集合接口提供的of(T...)方法创建空集合。例如，以下创建空List的两个方法是等价的：

List<String> list1 = List.of();
List<String> list2 = Collections.emptyList();

创建单元素集合

Collections提供了一系列方法来创建一个单元素集合：

创建一个元素的List：List<T> singletonList(T o)
创建一个元素的Map：Map<K, V> singletonMap(K key, V value)
创建一个元素的Set：Set<T> singleton(T o)

要注意到返回的单元素集合也是不可变集合，无法向其中添加或删除元素。

此外，也可以用各个集合接口提供的of(T...)方法创建单元素集合。例如，以下创建单元素List的两个方法是等价的：

List<String> list1 = List.of("apple");
List<String> list2 = Collections.singletonList("apple");

实际上，使用List.of(T...)更方便，因为它既可以创建空集合，也可以创建单元素集合，还可以创建任意个元素的集合：

List<String> list1 = List.of(); // empty list
List<String> list2 = List.of("apple"); // 1 element
List<String> list3 = List.of("apple", "pear"); // 2 elements
List<String> list4 = List.of("apple", "pear", "orange"); // 3 elements

排序

Collections可以对List进行排序。因为排序会直接修改List元素的位置，因此必须传入可变List：

public class Main {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("apple");list.add("pear");list.add("orange");// 排序前:System.out.println(list);Collections.sort(list);// 排序后:System.out.println(list);}
}

洗牌(打乱算法)

Collections提供了洗牌算法，即传入一个有序的List，可以随机打乱List内部元素的顺序，效果相当于让计算机洗牌：

public class Main {public static void main(String[] args) {List<Integer> list = new ArrayList<>();for (int i=0; i<10; i++) {list.add(i);}// 洗牌前:System.out.println(list);Collections.shuffle(list);// 洗牌后:System.out.println(list);}
}

不可变集合

Collections还提供了一组方法把可变集合封装成不可变集合：

封装成不可变List：List<T> unmodifiableList(List<? extends T> list)
封装成不可变Set：Set<T> unmodifiableSet(Set<? extends T> set)
封装成不可变Map：Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m)

这种封装实际上是通过创建一个代理对象，拦截掉所有修改方法实现的：

public class Main {public static void main(String[] args) {List<String> mutable = new ArrayList<>();mutable.add("apple");mutable.add("pear");// 变为不可变集合:List<String> immutable = Collections.unmodifiableList(mutable);immutable.add("orange"); // UnsupportedOperationException!}
}

然而，继续对原始的可变List进行增删是可以的，并且，会直接影响到封装后的“不可变”List：

public class Main {public static void main(String[] args) {List<String> mutable = new ArrayList<>();mutable.add("apple");mutable.add("pear");// 变为不可变集合:List<String> immutable = Collections.unmodifiableList(mutable);mutable.add("orange");System.out.println(immutable);}
}
output：[apple, pear, orange]

因此，如果我们希望把一个可变List封装成不可变List，那么，返回不可变List后，最好立刻扔掉可变List的引用，这样可以保证后续操作不会意外改变原始对象，从而造成“不可变”List变化了：

public class Main {public static void main(String[] args) {List<String> mutable = new ArrayList<>();mutable.add("apple");mutable.add("pear");// 变为不可变集合:List<String> immutable = Collections.unmodifiableList(mutable);// 立刻扔掉mutable的引用:mutable = null;System.out.println(immutable);}
}

线程安全集合

Collections还提供了一组方法，可以把线程不安全的集合变为线程安全的集合：

变为线程安全的List：List<T> synchronizedList(List<T> list)
变为线程安全的Set：Set<T> synchronizedSet(Set<T> s)
变为线程安全的Map：Map<K,V> synchronizedMap(Map<K,V> m)

（因为从Java 5开始，引入了更高效的并发集合类，所以上述这几个同步方法已经没有什么用了。）

【java快速入门-集合篇】- Iterator Collections