為什麼 Java ArrayList.toArray(T[]) 方法的參數類型是 T 而不是 E ？

前兩天給同事做 code review，感覺自己對 Java 的 Generics 掌握得不夠好，便拿出《Effective Java》1 這本書再看看相關的章節。在 Item 24：Eliminate unchecked warnings 這一節中，作者拿 ArrayList 類中的 publi ...

前兩天給同事做 code review，感覺自己對 Java 的 Generics 掌握得不夠好，便拿出《Effective Java》¹ 這本書再看看相關的章節。在 Item 24：Eliminate unchecked warnings 這一節中，作者拿 ArrayList 類中的 public <T> T[] toArray(T[] a) 方法作為例子來說明如何對變數使用 @SuppressWarnings annotation。

ArrayList 是一個 generic class，它是這樣聲明的：

public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

這個類的 toArray(T[] a) 方法是一個 generic method，它是這樣聲明和實現的：

 1: @SuppressWarnings("unchecked")
 2: public <T> T[] toArray(T[] a) {
 3:     if (a.length < size)
 4:         // Make a new array of a's runtime type, but my contents:
 5:         return (T[]) Arrays.copyOf(elementData, size, a.getClass());
 6:     System.arraycopy(elementData, 0, a, 0, size);
 7:     if (a.length > size)
 8:         a[size] = null;
 9:     return a;
10: }

這個方法實際上是在 Collection 介面中聲明的。因為我們經常通過 ArrayList 使用它，這裡就用 ArrayList 作為例子了。

1 為什麼聲明為不同類型？

我的問題是：為什麼這個方法使用類型 T，而不使用 ArrayList 的類型 E ? 也就是說，這個方法為什麼不聲明成這樣：

public E[] toArray(E[] a);

如果類型相同的話，在編譯期間就可以發現參數的類型錯誤。如果類型不同，很容易產生運行時錯誤。比如下麵這段代碼：

1: //創建一個類型為 String 的 ArrayList
2: List<String> strList = new ArrayList<String>();
3: strList.add("abc");
4: strList.add("xyz");
5: //將當前的 strList 轉換成一個 Number 數組。註意，下麵的語句沒有任何編譯錯誤。
6: Number[] numArray = strList.toArray(new Number[0]);

運行上面的代碼， Line 6 會拋出 java.lang.ArrayStoreException 異常。

如果 toArray 方法使用類型 E 的話，語句2就會產生編譯錯誤。編譯錯誤怎麼說也比運行時錯誤親切啊。並且，generics 的主要目的就是為了類型安全，把類型轉換錯誤(ClassCastException)消滅在編譯期間。這個方法卻反其道而行之。難道這是一個大 bug？ Java 的 bug 俺碰上過，但這個地方出 bug 我還是不太敢相信。

上網一查，這個問題早已被討論過多次了²^,³^,⁴。

2 可以提高靈活性

這樣的聲明更靈活，可以把當前 list 中的元素轉換成一個更一般類型的數組。比如，當前 list 的類型是 Integer，我們可以把它的元素轉換成一個 Number 數組。

1: List<Integer> intList = new ArrayList<Integer>();
2: intList.add(1);
3: intList.add(2);
4: Number[] numArray = intList.toArray(new Number[0]);

如果這個方法聲明成類型 E，上面的代碼就會有編譯錯誤。看起來，該方法聲明成下麵這樣會更合適：

public <T super E> T[] toArray(T[] a);

不過， <T super E> 這樣的語法在 Java 中是不存在的。而且即使存在，對數組也不起作用。也正是因為這個原因，在使用這個方法時，即使 T 是 E 的父類，或 T 跟 E 相同，也不能完全避免 java.lang.ArrayStoreException 異常⁵^,⁶^,⁷ 。請看下麵兩段代碼。第一段代碼中 T 是 E 的父類，第二段代碼中 T 和 E 一樣。這兩段代碼都會拋出異常。

代碼一：

1: List<Integer> intList = new ArrayList<Integer>();
2: intList.add(1);
3: intList.add(2);
4: 
5: Float[] floatArray = new Float[2];
6: //Float 是 Number 的子類，所以 Float[] 是 Number[] 的子類
7: Number[] numArray = floatArray;
8: //下麵的語句會拋出 ArrayStoreException 異常
9: numArray = intList.toArray(numArray);

代碼二：

 1: List<Number> intList = new ArrayList<Number>();
 2: //List 的類型是 Number。但 Number 是抽象類，只能存它的子類的實例
 3: intList.add(new Integer(1));
 4: intList.add(new Integer(2));
 5: 
 6: Float[] floatArray = new Float[2];
 7: //Float 是 Number 的子類，所以 Float[] 是 Number[] 的子類
 8: Number[] numArray = floatArray;
 9: //下麵的語句會拋出 ArrayStoreException 異常
10: numArray = intList.toArray(numArray);

上面的異常都是由這個事實造成的：如果 A 是 B 的父類，那麼 A[] 是 B[] 的父類。Java 中所有的類都繼承自 Object，Object[] 是所有數組的父類。

這個帖子⁸里舉了個例子，說明即使這個方法的類型聲明成 E 也不能避免 ArrayStoreException 異常。

該方法的文檔中也提到了這個異常：

ArrayStoreException if the runtime type of the specified array is not a supertype of the runtime type of every element in this list.

3 可以與 Java 1.5 之前的版本相容

這個方法在 Java 引入 Generics 之前（JDK1.5 中引入了 Generics）就出現了⁹。那時它被聲明稱這樣：

public Object[] toArray(Object[] a)

Generics 出現後，許多類和方法就變成 generic 的了。這個方法也隨大流聲明成這樣：

public <T> T[] toArray(T[] a)

這樣聲明可以與 Java 1.5 之前的版本相容¹⁰。

4 多啰嗦兩句

這個方法需要一個數組參數。如果這個數組的 length 大於或等於當前 list 的 size，list 中的元素就會存儲到這個數組當中；如果這個數組的 length 小於當前 list 的 size，就會創建一個新的數組，並把當前 list 中的元素存入到這個新創建的數組中。為提高效率，如果可能，傳入的數組的 length 要大於或等於 list 的 size，以避免該方法新建數組。

1: List<Integer> intList = new ArrayList<Integer>();
2: intList.add(1);
3: intList.add(2);
4: //傳入一個數組，它的長度為 0 
5: Number[] numArray1 = intList.toArray(new Number[0]); //語句1
6: //傳入一個數組，它的長度與 intList 的長度相等
7: Number[] numArray2 = intList.toArray(new Number[intList.size()]); //語句2