目录
本笔记参考自： 《On Java 中文版》
Collection和Iterator的对比
Collection是所有序列集合的共同根接口。因此，可以认为它是一个为表示其他接口之间的共性而出现的“附属接口”。
java.util.AbstractCollection提供了一个Collection的默认实现，所以可以通过创建AbstractCollection的新子类来避免不必要的代码重复。这种接口存在的另一个理由是，通过面向接口的编程方式，我们的代码可以变得更加通用。一个实现了接口的方法也可以应用于任何的Collection类型。
在Java中，实现Collection需要提供iterator()方法，这就将迭代器和集合捆绑起来了。
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.List;
public class InterfaceVsIterator {
public static void display(Iterator<Pet> it) {
while (it.hasNext()) {
Pet p = it.next();
System.out.print(p.id() + ": " + p + " ");
}
System.out.println();
}
public static void display(Collection<Pet> pets) {
for (Pet p : pets)
System.out.print(p.id() + ": " + p + " ");
System.out.println();
}
public static void main(String[] args) {
List<Pet> petList = new PetCreator().list(8);
Set<Pet> petSet = new HashSet<>(petList);
Map<String, Pet> petMap = new LinkedHashMap<>();
String[] names = ("拉尔夫, 埃里克, 罗宾, 蕾西, " + "布里特妮, 山姆, 斑点, 路威").split(", ");
for (int i = 0; i < names.length; i++)
petMap.put(names[i], petList.get(i));
// Collection
display(petList);
display(petSet);
// Iterator
System.out.println();
display(petList.iterator());
display(petSet.iterator());
System.out.println();
System.out.println(petMap);
System.out.println(petMap.keySet());
display(petMap.values());
display(petMap.values().iterator());
}
}程序执行的结果是：
（笔者使用的是JDK 11，输出结果与《On Java》中有所出入。推测是因为哈希的实现有区别。）
在上述程序中可以发现，Collection和Iterator都实现了解耦，display()方法不需要理解底层集合的特定实现。
若要实现一个不是Collection的外部类，让其实现Collection接口可能会很麻烦或是复杂的，这时就会体现出Iterator的优势了。下面的例子将会继承AbstractCollection类：
import java.util.AbstractCollection;
import java.util.Iterator;
public class CollectionSequence extends AbstractCollection {
private Pet[] pets = new PetCreator().array(8); // 返回一个Pet[]数组
@Override
public int size() { // 必须实现的接口方法size()
return pets.length;
}
@Override
public Iterator<Pet> iterator() { // 必须自己提供iterator()方法
return new Iterator<Pet>() { // Java的类型推断能力有限，所以这里还是需要标明类型
private int index = 0;
@Override
public boolean hasNext() {
return index < pets.length;
}
@Override
public Pet next() {
return pets[index++];
}
@Override
public void remove() { // remove是可选的实现，就算这里不进行实现也没有关系
throw new UnsupportedOperationException();
}
};
}
public static void main(String[] args) {
CollectionSequence c = new CollectionSequence();
InterfaceVsIterator.display(c);
InterfaceVsIterator.display(c.iterator());
}
}程序执行的结果如下：
这个例子实现了一个Collection，为此还提供了一个iterator()的实现。但这里我们就发现，与继承AbstractCollection类相比，只实现iterator()所需的工作并没有减少太多。另外，实现Collection还需要提供我们并不需要使用的其他方法的实现。
所以，先继承，在添加创建迭代器的能力，这样会比较轻松：
生成一个Iterator，是将序列与处理序列的方法连接起来的耦合性最低的方法。与Collection相比，这种做法对序列类的约束会少的多。
for-in和迭代器
for-in语法可以配合任何Collection对象使用：
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
public class ForInCollections {
public static void main(String[] args) {
Collection<String> cs = new LinkedList<>();
Collections.addAll(cs, "不吃葡萄倒吐葡萄皮".split(""));
for (String s : cs)
System.out.print("'" + s + "'");
System.out.println();
}
}程序执行的结果如下：
for-in语句之所以能这么做，其原理是因为Java 5引入了一个叫做Iterable的接口，这个接口包含的iterator()方法会生成一个Iterator。for-in使用这个Iterable接口遍历序列。
举一反三，若我们创建了一个实现了Iterable接口的类，那么这个类也就可以被用于for-in语句中：
import java.util.Iterator;
public class IterableClass implements Iterable<String> {
protected String[] words = ("扁担没有板凳宽，板凳没有扁担长".split(""));
@Override
public Iterator<String> iterator() {
return new Iterator<String>() {
private int index = 0;
@Override
public boolean hasNext() {
return index < words.length;
}
@Override
public String next() {
return words[index++];
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
public static void main(String[] args) {
for (String s : new IterableClass())
System.out.print(s + " ");
System.out.println();
}
}程序执行的结果如下：
for-in语句可以配合数组或实现了Iterable接口的类进行使用，但这并不是说数组也自动实现了Iterable，也并不存在任何装箱操作：
import java.util.Arrays;
public class ArrayIsNotIterable {
static <T> void test(Iterable<T> ib) {
for (T t : ib)
System.out.print(t + " ");
System.out.println();
}
public static void main(String[] args) {
test(Arrays.asList(1, 2, 3));
String[] strings = { "A", "B", "C" };
// 数组可以配合for-in进行使用
// 但并没有实现Iterable接口，因此无法作为参数传入test()
// test(strings);
// 必须将strings显式地转换为Iterable：
test(Arrays.asList(strings));
}
}程序执行的结果如下：
适配器方法惯用法
当我们需要以不止一种方式将类用在for-in语句时，继承就不能很好地满足我们了。此时，我们需要做的是提供一个满足for-in语句要求的特定接口。比如：默认的迭代器是向前的，若我们还需要进行向后的迭代，那么一个好的方法就是添加一个生成Iterable对象的方法：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
class ReversibleArrayList<T> extends ArrayList<T> {
ReversibleArrayList(Collection<T> c) {
super(c);
}
public Iterable<T> reversed() { // 添加一个迭代器
return new Iterable<T>() {
public Iterator<T> iterator() {
return new Iterator<T>() {
int current = size() - 1;
@Override
public boolean hasNext() {
return current > -1;
}
@Override
public T next() {
return get(current--);
}
@Override
public void remove() { // 未实现
throw new UnsupportedOperationException();
}
};
}
};
}
}
public class AdapterMethodIdiom {
public static void main(String[] args) {
ReversibleArrayList<String> ral = new ReversibleArrayList<>(
Arrays.asList("To be continued".split(" ")));
// 通过iterator()获得原始的迭代器
for (String s : ral)
System.out.print(s + " ");
System.out.println();
// 使用自建的迭代器
for (String s : ral.reversed())
System.out.print(s + " ");
System.out.println();
}
}程序执行的结果是：
在main()，可以看见调用ral和ral.reversed()产生的是不同的行为。
另外，迭代器也可以通过使用其他类来实现：
上述这个类将会返回一个被打乱的Iterator。
最后再提一下Arrays.asList()，这个方法会返回一个包装过的ArrayList。若将包装后的ArrayList传递给Collections.shuffle()，那么原始数组不会受到影响。但若直接将Arrays.asList()生成的List打乱顺序，那么shuffle()方法会改变底层数组：
import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
public class ModifyingArraysAsList {
public static void main(String[] args) {
Random rand = new Random(47);
Integer[] ia = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<Integer> list1 = new ArrayList<>(Arrays.asList(ia)); //
System.out.println("在乱序之前：" + list1);
Collections.shuffle(list1, rand);
System.out.println("在乱序之后：" + list1);
System.out.println("数组本身：" + Arrays.toString(ia));
System.out.println();
List<Integer> list2 = Arrays.asList(ia);
System.out.println("在乱序之前：" + list2);
Collections.shuffle(list2, rand);
System.out.println("在乱序之后：" + list2);
System.out.println("数组本身：" + Arrays.toString(ia));
}
}程序执行的结果如下：
注意：Arrays.asList()产生的List对象，会将原本的底层数组作为其物理实现。所以，若需要修改List，最好将其复制到另一个集合中。
总结图
扫一扫
1232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
