關於Java Collections API您不知道的5件事，第1部分

定制和擴展 Java Collections

對於很多 Java 開發人員來說，Java Collections API 是標准 Java 數組及其所有缺點的一個非常需要的替代品。將 Collections 主 要與 ArrayList 聯系到一起本身沒有錯，但是對於那些有探索精神的人來說，這只是 Collections 的冰山一角。

雖然 Map（以及它的常用實現 HashMap）非常適合名-值對或鍵-值對，但是沒有理由讓自己局限於這些熟悉的工具。可以使用適當的 API，甚至適當的 Collection 來修正很多易錯的代碼。

本文是 5 件事 系列 中的第二篇文章，也是專門討論 Collections 的 7 篇文章中的第一篇文章，之所以花這麼大的篇幅討論 Collections，是因為這些集合在 Java 編程中是如此重要。首先我將討論做每件事的最快（但也許不是最常見）的方式，例如將 Array 中的內容轉移到 List。然後我們深入探討一些較少人知道的東西，例如編寫定制的 Collections 類和擴展 Java Collections API。

1. Collections 比數組好

剛接觸 Java 技術的開發人員可能不知道，Java 語言最初包括數組，是為了應對上世紀 90 年代初期 C++ 開發人員對於性能方面的批 評。從那時到現在，我們已經走過一段很長的路，如今，與 Java Collections 庫相比，數組不再有性能優勢。

例如，若要將數組的內容轉儲到一個字符串，需要迭代整個數組，然後將內容連接成一個 String；而 Collections 的實現都有一個可 用的 toString() 實現。

除少數情況外，好的做法是盡快將遇到的任何數組轉換成集合。於是問題來了，完成這種轉換的最容易的方式是什麼？事實證明，Java Collections API 使這種轉換變得容易，如清單 1 所示：

清單 1. ArrayToList

import　java.util.*;

public　class　ArrayToList
{
　　 public　static　void　main(String[]　args)
　　 {
　　　　 //　This　gives　us　nothing　good
　　　　 System.out.println(args);

　　　　 //　Convert　args　to　a　List　of　String
　　　　 List<String>　argList　=　Arrays.asList(args);

　　　　 //　Print　them　out
　　　　 System.out.println(argList);
　　 }
}

注意，返回的 List 是不可修改的，所以如果嘗試向其中添加新元素將拋出一個 UnsupportedOperationException。

而且，由於 Arrays.asList() 使用 varargs 參數表示添加到 List 的元素，所以還可以使用它輕松地用以 new 新建的對象創建 List 。

2. 迭代的效率較低

將一個集合（特別是由數組轉化而成的集合）的內容轉移到另一個集合，或者從一個較大對象集合中移除一個較小對象集合，這些事情 並不鮮見。

您也許很想對集合進行迭代，然後添加元素或移除找到的元素，但是不要這樣做。

在此情況下，迭代有很大的缺點：

每次添加或移除元素後重新調整集合將非常低效。

每次在獲取鎖、執行操作和釋放鎖的過程中，都存在潛在的並發困境。

當添加或移除元素時，存取集合的其他線程會引起競爭條件。

可以通過使用 addAll 或 removeAll，傳入包含要對其添加或移除元素的集合作為參數，來避免所有這些問題。

3. 用 for 循環遍歷任何 Iterable

Java 5 中加入 Java 語言的最大的便利功能之一，增強的 for 循環，消除了使用 Java 集合的最後一道障礙。

以前，開發人員必須手動獲得一個 Iterator，使用 next() 獲得 Iterator 指向的對象，並通過 hasNext() 檢查是否還有更多可用對 象。從 Java 5 開始，我們可以隨意使用 for 循環的變種，它可以在幕後處理上述所有工作。

實際上，這個增強適用於實現 Iterable 接口的任何對象，而不僅僅是 Collections。

清單 2 顯示通過 Iterator 提供 Person 對象的孩子列表的一種方法。 這裡不是提供內部 List 的一個引用 （這使 Person 外的調 用者可以為家庭增加孩子 — 而大多數父母並不希望如此），Person 類型實現 Iterable。這種方法還使得 for 循環可以遍歷所有孩子。

清單 2. 增強的 for 循環：顯示孩子

//　Person.java
import　java.util.*;

public　class　Person
　　 implements　Iterable<Person>
{
　　 public　Person(String　fn,　String　ln,　int　a,　Person...　kids)
　　 {
　　　　 this.firstName　=　fn;　this.lastName　=　ln;　this.age　=　a;
　　　　 for　(Person　child　:　kids)
　　　　　　 children.add(child);
　　 }
　　 public　String　getFirstName()　{　return　this.firstName;　}
　　 public　String　getLastName()　{　return　this.lastName;　}
　　 public　int　getAge()　{　return　this.age;　}

　　 public　Iterator<Person>　iterator()　{　return　children.iterator();　}

　　 public　void　setFirstName(String　value)　{　this.firstName　=　value;　}
　　 public　void　setLastName(String　value)　{　this.lastName　=　value;　}
　　 public　void　setAge(int　value)　{　this.age　=　value;　}

　　 public　String　toString()　{
　　　　 return　"[Person:　"　+
　　　　　　 "firstName="　+　firstName　+　"　"　+
　　　　　　 "lastName="　+　lastName　+　"　"　+
　　　　　　 "age="　+　age　+　"]";
　　 }

　　 private　String　firstName;
　　 private　String　lastName;
　　 private　int　age;
　　 private　List<Person>　children　=　new　ArrayList<Person>();
}

//　App.java
public　class　App
{
　　 public　static　void　main(String[]　args)
　　 {
　　　　 Person　ted　=　new　Person("Ted",　"Neward",　39,
　　　　　　 new　Person("Michael",　"Neward",　16），
　　　　　　 new　Person("Matthew",　"Neward",　10));

　　　　 //　Iterate　over　the　kids
　　　　 for　(Person　kid　:　ted)
　　　　 {
　　　　　　 System.out.println(kid.getFirstName());
　　　　 }
　　 }
}

在域建模的時候，使用 Iterable 有一些明顯的缺陷，因為通過 iterator() 方法只能那麼 “隱晦” 地支持一個那樣的對象集合。但 是，如果孩子集合比較明顯，Iterable 可以使針對域類型的編程更容易，更直觀。

4. 經典算法和定制算法

您是否曾想過以倒序遍歷一個 Collection？對於這種情況，使用經典的 Java Collections 算法非常方便。

在上面的 清單 2 中，Person 的孩子是按照傳入的順序排列的；但是，現在要以相反的順序列出他們。雖然可以編寫另一個 for 循環 ，按相反順序將每個對象插入到一個新的 ArrayList 中，但是 3、4 次重復這樣做之後，就會覺得很麻煩。

在此情況下，清單 3 中的算法就有了用武之地：

清單 3. ReverseIterator

public　class　ReverseIterator
{
　　 public　static　void　main(String[]　args)
　　 {
　　　　 Person　ted　=　new　Person("Ted",　"Neward",　39,
　　　　　　 new　Person("Michael",　"Neward",　16），
　　　　　　 new　Person("Matthew",　"Neward",　10));

　　　　 //　Make　a　copy　of　the　List
　　　　 List<Person>　kids　=　new　ArrayList<Person>(ted.getChildren());
　　　　 //　Reverse　it
　　　　 Collections.reverse(kids);
　　　　 //　Display　it
　　　　 System.out.println(kids);
　　 }
}

Collections 類有很多這樣的 “算法”，它們被實現為靜態方法，以 Collections 作為參數，提供獨立於實現的針對整個集合的行為 。

而且，由於很棒的 API 設計，我們不必完全受限於 Collections 類中提供的算法 — 例如，我喜歡不直接修改（傳入的 Collection 的）內容的方法。所以，可以編寫定制算法是一件很棒的事情，例如清單 4 就是一個這樣的例子：

清單 4. ReverseIterator 使事情更簡單

class　MyCollections
{
　　 public　static　<T>　List<T>　reverse(List<T>　src)
　　 {
　　　　 List<T>　results　=　new　ArrayList<T>(src);
　　　　 Collections.reverse(results);
　　　　 return　results;
　　 }
}　

5. 擴展 Collections API

以上定制算法闡釋了關於 Java Collections API 的一個最終觀點：它總是適合加以擴展和修改，以滿足開發人員的特定目的。

例如，假設您需要 Person 類中的孩子總是按年齡排序。雖然可以編寫代碼一遍又一遍地對孩子排序（也許是使用 Collections.sort 方法），但是通過一個 Collection 類來自動排序要好得多。

實際上，您甚至可能不關心是否每次按固定的順序將對象插入到 Collection 中（這正是 List 的基本原理）。您可能只是想讓它們按 一定的順序排列。

java.util 中沒有 Collection 類能滿足這些需求，但是編寫一個這樣的類很簡單。只需創建一個接口，用它描述 Collection 應該提 供的抽象行為。對於 SortedCollection，它的作用完全是行為方面的。

清單 5. SortedCollection

public　interface　SortedCollection<E>　extends　Collection<E>
{
　　 public　Comparator<E>　getComparator();
　　 public　void　setComparator(Comparator<E>　comp);
}

編寫這個新接口的實現簡直不值一提：

清單 6. ArraySortedCollection

import　java.util.*;

public　class　ArraySortedCollection<E>
　　 implements　SortedCollection<E>,　Iterable<E>
{
　　 private　Comparator<E>　comparator;
　　 private　ArrayList<E>　list;

　　 public　ArraySortedCollection(Comparator<E>　c)
　　 {
　　　　 this.list　=　new　ArrayList<E>();
　　　　 this.comparator　=　c;
　　 }
　　 public　ArraySortedCollection(Collection<?　extends　E>　src,　Comparator<E>　c)
　　 {
　　　　 this.list　=　new　ArrayList<E>(src);
　　　　 this.comparator　=　c;
　　　　 sortThis();
　　 }

　　 public　Comparator<E>　getComparator()　{　return　comparator;　}
　　 public　void　setComparator(Comparator<E>　cmp)　{　comparator　=　cmp;　sortThis();　}

　　 public　boolean　add(E　e)
　　 {　boolean　r　=　list.add(e);　sortThis();　return　r;　}
　　 public　boolean　addAll(Collection<?　extends　E>　ec)
　　 {　boolean　r　=　list.addAll(ec);　sortThis();　return　r;　}
　　 public　boolean　remove(Object　o)
　　 {　boolean　r　=　list.remove(o);　sortThis();　return　r;　}
　　 public　boolean　removeAll(Collection<?>　c)
　　 {　boolean　r　=　list.removeAll(c);　sortThis();　return　r;　}
　　 public　boolean　retainAll(Collection<?>　ec)
　　 {　boolean　r　=　list.retainAll(ec);　sortThis();　return　r;　}

　　 public　void　clear()　{　list.clear();　}
　　 public　boolean　contains(Object　o)　{　return　list.contains(o);　}
　　 public　boolean　containsAll(Collection　<?>　c)　{　return　list.containsAll(c);　}
　　 public　boolean　isEmpty()　{　return　list.isEmpty();　}
　　 public　Iterator<E>　iterator()　{　return　list.iterator();　}
　　 public　int　size()　{　return　list.size();　}
　　 public　Object[]　toArray()　{　return　list.toArray();　}
　　 public　<T>　T[]　toArray(T[]　a)　{　return　list.toArray(a);　}

　　 public　boolean　equals(Object　o)
　　 {
　　　　 if　(o　==　this)
　　　　　　 return　true;

　　　　 if　(o　instanceof　ArraySortedCollection)
　　　　 {
　　　　　　 ArraySortedCollection<E>　rhs　=　(ArraySortedCollection<E>)o;
　　　　　　 return　this.list.equals(rhs.list);
　　　　 }

　　　　 return　false;
　　 }
　　 public　int　hashCode()
　　 {
　　　　 return　list.hashCode();
　　 }
　　 public　String　toString()
　　 {
　　　　 return　list.toString();
　　 }

　　 private　void　sortThis()
　　 {
　　　　 Collections.sort(list,　comparator);
　　 }
}

這個實現非常簡陋，編寫時並沒有考慮優化，顯然還需要進行重構。但關鍵是 Java Collections API 從來無意將與集合相關的任何東 西定死。它總是需要擴展，同時也鼓勵擴展。

當然，有些擴展比較復雜，例如 java.util.concurrent 中引入的擴展。但是另一些則非常簡單，只需編寫一個定制算法，或者已有 Collection 類的簡單的擴展。

擴展 Java Collections API 看上去很難，但是一旦開始著手，您會發現遠不如想象的那樣難。

結束語

和 Java Serialization 一樣，Java Collections API 還有很多角落等待有人去探索 —正因為如此，我們還不准備結束這個話題。在 5 件事 系列 的下一篇文章中，將可以看到用 Java Collections API 做更多事情的 5 種新的方式。

原文地址：http://www.ibm.com/developerworks/cn/java/j-5things2.html