## [集合與迭代器](https://lingcoder.gitee.io/onjava8/#/book/12-Collections?id=%e9%9b%86%e5%90%88%e4%b8%8e%e8%bf%ad%e4%bb%a3%e5%99%a8) **Collection**是所有序列集合共有的根接口。它可能會被認為是一種“附屬接口”（incidental interface），即因為要表示其他若干個接口的共性而出現的接口。此外，**java.util.AbstractCollection**類提供了**Collection**的默認實現，使得你可以創建**AbstractCollection**的子類型，而其中沒有不必要的代碼重復。 使用接口描述的一個理由是它可以使我們創建更通用的代碼。通過針對接口而非具體實現來編寫代碼，我們的代碼可以應用于更多類型的對象。\[^6\]因此，如果所編寫的方法接受一個**Collection**，那么該方法可以應用于任何實現了**Collection**的類——這也就使得一個新類可以選擇去實現**Collection**接口，以便該方法可以使用它。標準 C++ 類庫中的集合并沒有共同的基類——集合之間的所有共性都是通過迭代器實現的。在 Java 中，遵循 C++ 的方式看起來似乎很明智，即用迭代器而不是**Collection**來表示集合之間的共性。但是，這兩種方法綁定在了一起，因為實現**Collection**就意味著需要提供`iterator()`方法： ~~~ // collections/InterfaceVsIterator.java import typeinfo.pets.*; import java.util.*; 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 = Pets.list(8); Set<Pet> petSet = new HashSet<>(petList); Map<String, Pet> petMap = new LinkedHashMap<>(); String[] names = ("Ralph, Eric, Robin, Lacey, " + "Britney, Sam, Spot, Fluffy").split(", "); for(int i = 0; i < names.length; i++) petMap.put(names[i], petList.get(i)); display(petList); display(petSet); display(petList.iterator()); display(petSet.iterator()); System.out.println(petMap); System.out.println(petMap.keySet()); display(petMap.values()); display(petMap.values().iterator()); } } /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx {Ralph=Rat, Eric=Manx, Robin=Cymric, Lacey=Mutt, Britney=Pug, Sam=Cymric, Spot=Pug, Fluffy=Manx} [Ralph, Eric, Robin, Lacey, Britney, Sam, Spot, Fluffy] 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx */ ~~~ 兩個版本的`display()`方法都可以使用**Map**或**Collection**的子類型來工作。 而且**Collection**接口和**Iterator**都將`display()`方法與低層集合的特定實現解耦。 在本例中，這兩種方式都可以奏效。事實上，**Collection**要更方便一點，因為它是**Iterable**類型，因此在`display(Collection)`的實現中可以使用*for-in*構造，這使得代碼更加清晰。 當需要實現一個不是**Collection**的外部類時，由于讓它去實現**Collection**接口可能非常困難或麻煩，因此使用**Iterator**就會變得非常吸引人。例如，如果我們通過繼承一個持有**Pet**對象的類來創建一個**Collection**的實現，那么我們必須實現**Collection**所有的方法，即使我們不在`display()`方法中使用它們，也必須這樣做。雖然這可以通過繼承**AbstractCollection**而很容易地實現，但是無論如何還是要被強制去實現`iterator()`和`size()`方法，這些方法**AbstractCollection**沒有實現，但是**AbstractCollection**中的其它方法會用到： ~~~ // collections/CollectionSequence.java import typeinfo.pets.*; import java.util.*; public class CollectionSequence extends AbstractCollection<Pet> { private Pet[] pets = Pets.array(8); @Override public int size() { return pets.length; } @Override public Iterator<Pet> iterator() { return new Iterator<Pet>() { // [1] private int index = 0; @Override public boolean hasNext() { return index < pets.length; } @Override public Pet next() { return pets[index++]; } @Override public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } public static void main(String[] args) { CollectionSequence c = new CollectionSequence(); InterfaceVsIterator.display(c); InterfaceVsIterator.display(c.iterator()); } } /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx */ ~~~ `remove()`方法是一個“可選操作”，在[附錄：集合主題](https://lingcoder.gitee.io/onjava8/#/)中詳細介紹。 這里可以不必實現它，如果你調用它，它將拋出異常。 * **\[1\]**你可能會認為，因為`iterator()`返回**Iterator**，匿名內部類定義可以使用菱形語法，Java可以推斷出類型。但這不起作用，類型推斷仍然非常有限。 這個例子表明，如果實現了**Collection**，就必須實現`iterator()`，并且只拿實現`iterator()`與繼承**AbstractCollection**相比，花費的代價只有略微減少。但是，如果類已經繼承了其他的類，那么就不能再繼承**AbstractCollection**了。在這種情況下，要實現**Collection**，就必須實現該接口中的所有方法。此時，繼承并提供創建迭代器的能力要容易得多： ~~~ // collections/NonCollectionSequence.java import typeinfo.pets.*; import java.util.*; class PetSequence { protected Pet[] pets = Pets.array(8); } public class NonCollectionSequence extends PetSequence { public Iterator<Pet> iterator() { return new Iterator<Pet>() { private int index = 0; @Override public boolean hasNext() { return index < pets.length; } @Override public Pet next() { return pets[index++]; } @Override public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } public static void main(String[] args) { NonCollectionSequence nc = new NonCollectionSequence(); InterfaceVsIterator.display(nc.iterator()); } } /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx */ ~~~ 生成**Iterator**是將序列與消費該序列的方法連接在一起耦合度最小的方式，并且與實現**Collection**相比，它在序列類上所施加的約束也少得多。