作者：Yvon Sauvageau
摘要
將 applet 參數化通常是一項煩瑣的工作，包括在 applet 的 init() 方法中添加很多重復的代碼行。上個月，Java 技巧的撰稿人 Yvon Sauvageau 向您講述了如何將這些代碼縮減為一行，這要歸功於類反射機制。但是，他沒有說明如何實現數組初始化。本技巧將說明使數組自動初始化的細節。
上個月，我在 Java Tip 57，"Applet parameterization via class reflection" 中提供了一個出色的方法來使 applet 參數化。參數化是指借助嵌入在 Html 文件中的 PARAM 標記來傳遞參數。這個方法用起來很方便，因為它完成了全部的參數提取工作，使您在相當長的時間內不必輸入 getParameter。但在上一篇技巧中我沒提及如何實現數組初始化。本月的這篇技巧將為您講述這個問題。
本文假定您比較熟悉類反射機制，盡管您可能在查看代碼時就能對它有所了解。類反射機制的功能部件位於 java.lang.reflect 軟件包內。這種機制使您能夠檢查類的結構，還可提供域、方法、訪問修飾符等的運行時信息。
將列表數據提供給 applet
看過關於 applet 參數化的上一篇技巧的讀者可能已經注重到：我們的方法沒有對一類重要的對象進行初始化。在本文中，我們將研究假如利用類反射機制對一維數組和二位數組進行初始化。我知道只有實現對更高維數組的處理才能使狂熱的科學家滿足，但我將把那項工作作為練習留給您。
在我的上一篇技巧中，只能處理基本類型的數組和字符串數組。考慮到任何對象最終都能由基本數據類型和字符串構建而來，所以這將不會構成多大的限制。當然，很輕易將我們的技術加以擴展，之後就能直接對其他類型的數據進行初始化。
數組是用來存儲列表數據的理想數據結構。我們的技術使得向 applet 傳遞列表參數變得很簡單。 通常利用動態生成 HTML 文檔的程序（如 servlet 或 CGI 腳本）將列表數據傳遞給 applet。作為示例，我們設想一個比賽記分板 applet。HTML 生成器將會將當前的記分板數據庫輸出到 PARAM 標記中，接著相應的數組將被完全初始化 -- 這要歸功於我們的參數提取方法。
列表數據項的語法
我們要實現的就是一個從 PARAM 標記中提取一維或是二維數組的方法。一維數組的語法是：
PARAM NAME="myArray" VALUE="element1 element2 ... elementN"
各元素之間的定界符是空格。
二位數組的語法是：
PARAM NAME="myMatrix" VALUE="element11 element12 element13
element21 element22 element23
element31 element32 element33"
各行之間的定界符是 符號。這裡，myMatrix 是一個 (3 x 3) 數組。
注重：Java 支持不規則數組。 不規則數組就是各行的長度不同的數組。例如，HTML 作者可能會按以下方式輸入帕斯卡三角形：
PARAM NAME="pascalTriangle" VALUE=" 1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1"
初始化完成之後，pascalTriangle 域的內容將是：
pascalTriangle[0] = {1}
pascalTriangle[1] = {1, 1}
pascalTriangle[2] = {1, 2, 1}
pascalTriangle[3] = {1, 3, 3, 1}
pascalTriangle[4] = {1, 4, 6, 4, 1}
pascalTriangle[5] = {1, 5, 10, 10, 5, 1}
pascalTriangle[5] = {1, 6, 15, 20, 15, 6, 1}
通常，程序員應該只聲明 pascalTriangle，而不進行內存分配。我們的提取方法負責分配內存。但讓我們假定已為第四行分配了內存，如下所示：
pascalTriangle[3] = new int[2];
我們的方法將只提取前兩個元素。這樣，第四行的初始化結果將是：
pascalTriangle[3] = {1, 3}
數組知識回顧
正如您在以上代碼清單中看到的那樣，我們的方法實現有點“深奧”。因此，在研究源代碼之前回顧有關數組的幾點知識是個不錯的主意。
我們都對 Java 的類型層次結構比較熟悉：Java 有一組預定義的基本數據類型（int、float...），還有 Object 的子類的一個繼續樹，Object 類是所有類的最終超類。但 Java 中還存在一個不很出名的平行層次結構，我稱其為數組層次結構。您無論何時在類型層次結構中定義了一個新類型 Foo，您實際上也同時定義了一個自動結合到數組層次結構中的新類型 Foo[]。數組層次結構中的每個類（基本數據類型的數組除外）都是 Object[] 的子類。輕易引起混淆的是：Object[] 和基本數據類型的數組都是 Object 的子類。圖 1 表明了這一點。
圖 1：兩個平行的層次結構
令人感到希奇的是，Java 根本就沒有多維數組，只有一維數組。多維數組實際上是“一維數組的數組的數組的數組...”。因此，我們可以創建不規則數組。事實上，我們甚至可以不對某些行進行初始化，而將它們保留為空值。
數組提取方法的實現
現在我們可以查看源代碼了。正如您所見，其中加了大量注釋。通常，包含如此多的注釋不是個好習慣，但在這裡，我們要將已經抽象的 Java 數組包裝在由類反射機制提供的元數據抽象層中。結果，多數程序語句都不能表明其自身的含義，所以在這種情況下對幾乎每個代碼行作注釋是無可非議的。
無論何時對一維或是二維數組進行初始化，最終我們都需要用 HTML 作者輸入的行對一維數組進行初始化。我們設計了一個方法來完成這一操作：
/**
* 用符號處理器 (tokenizer) 的內容填充一維數組。
* 符號被轉換為數組的內容類型。
*
* @param array 要填充的數組。
* @param elementTokens 包含要填入數組的符號的符號處理器。
*/
private static void fillOneDimensionalArray(Object array,
StringTokenizer elementTokens)
throws IllegalAccessException {
if (array != null && elementTokens != null && array.getClass().isArray()) { // 雙重檢驗。
// 數組應該容納哪種類型的元素？
Class componentType = array.getClass().getComponentType();
int numElements = elementTokens.countTokens();
// 為數組元素賦值。
//
// 請注重，我們確保索引不會超出范圍。可能未給數組分配組足夠的空間，
// 以致無法容納分析後的全部元素。
for (int j = 0; j < Array.getLength(array) && j < numElements; j++) {
// 將符號轉換為數組所容納的類型。
// 然後將其添加到數組中。
if (componentType.equals(boolean.class))
Array.setBoolean(array, j, Boolean.valueOf(elementTokens.nextToken().trim()).booleanValue());
else if (componentType.equals(byte.class))
Array.setByte(array, j, Byte.valueOf(elementTokens.nextToken().trim()).byteValue());
else if (componentType.equals(char.class))
Array.setChar(array, j, elementTokens.nextToken().charAt(0));
else if (componentType.equals(double.class))
Array.setDouble(array, j, Double.valueOf(elementTokens.nextToken().trim()).doubleValue());
else if (componentType.equals(float.class))
Array.setFloat(array, j, Float.valueOf(elementTokens.nextToken().trim()).floatValue());
else if (componentType.equals(int.class))
Array.setInt(array, j, Integer.valueOf(elementTokens.nextToken().trim()).intValue());
else if (componentType.equals(long.class))
Array.setLong(array, j, Long.valueOf(elementTokens.nextToken().trim()).longValue());
else if (componentType.equals(short.class))
Array.setShort(array, j, Short.valueOf(elementTokens.nextToken().trim()).shortValue());
else if (componentType.equals(String.class))
Array.set(array, j, elementTokens.nextToken());
}
}
}
我們使用 Class.getComponentType() 方法獲取給定數組對象所容納的元素類型。一旦我們獲得這些信息，我們就知道應將行元素轉換為何種類型。這是在一個循環語句中完成的。
您可能已猜到了，Array.setByte(Object obj, int i, byte datum) 用字節變量 datum 為 obj 數組的第 i 個元素賦值。這相當於 ((byte[])obj)[i] = datum。
下面開始分析實現的核心部分。我對 Util.initializeApplet(Applet, String) 方法（在“Java 技巧 57”中實現）進行了擴展，在其中添加了一個條件語句，這個條件語句高速緩存數組域並對它們進行初始化。
import java.applet.*;
import java.lang.reflect.*;
import java.util.*;
public abstract class Util {
/**
* 對 applet 的名稱以給定篩選前綴開頭的非 final 公共域進行初始化。
* 初始值將從 HTML PARAM 標記中讀取。
* *
* @param applet 要初始化的 applet。
* @param filterPrefix 只對那些以此前綴開頭的域進行初始化。
*
* 假如前綴為空值，將對所有非 final 公共域進行初始化。
*/
public static void initializeApplet(Applet applet, String filterPrefix) {
Class metaclass = applet.getClass();
Field[] fields = metaclass.getFields();
String param = null;
for (int i = 0; i < fields.length; i++) {
try {
param = applet.getParameter(fields[i].getName());
if (param == null
Modifier.isFinal(fields[i].getModifiers())
((filterPrefix != null) &&
!fields[i].getName().startsWith(filterPrefix))
)
continue;
Class fieldType = fields[i].getType();
if (fieldType.equals(boolean.class)) {
fields[i].setBoolean(applet, Boolean.valueOf(param).booleanValue());
}
else if (fieldType.equals(byte.class)) {
fields[i].setByte(applet, Byte.valueOf(param).byteValue());
}
/*********************************************
* 具體細節已被刪除。請參閱上一篇文章。
* 要獲得完整的代碼，請下載源文件。
*********************************************/
// 對數組進行初始化。
else if (fieldType.isArray()) {
// 此處我們知道正在處理的域是一個數組。
// 但數組要容納何種類型的元素呢？
Class componentType = fieldType.getComponentType();
// 對一維數組進行初始化。
if (componentType.isPrimitive()
componentType.equals(String.class)) {
// 用 StringTokenizer 分析由 HTML 作者提供的數組元素。
StringTokenizer elementTokens = new StringTokenizer(param);
int numElements = elementTokens.countTokens();
// 請注重，fields[i] 只是表示數組對象的元數據域。
// 我們需要一個數組引用，以便為它的元素賦值。
//
// 這樣：
Object array = fields[i].get(applet);
// 如因某種原因已構造了數組，
// 則使它保持原樣。
// 否則：以適當的類型構造數組，
// 並為其分配足夠的內存空間，
// 以容納由 HTML 作者提供全部元素。
if (array == null) {
// 構造類型為 componentType 的數組，
// 並為 numElements 分配空間。
fields[i].set(applet, Array.newInstance(componentType, numElements));
// 獲取剛構造的數組的引用。
array = fields[i].get(applet);
}
// 用包含在 elementTokens 中的元素填充數組。
fillOneDimensionalArray(array, elementTokens);
}
// 對二維數組進行初始化。
else if (componentType.isArray() &&
(componentType.getComponentType().isPrimitive()
componentType.getComponentType().equals(String.class))) {
// 子數組（即各行）由 "" 符號分隔。
// 使用這種定界符將二維表分解成一系列表示一維數組的
// 符號。我們稱之為子數組。
StringTokenizer subarrayTokens = new StringTokenizer(param, "");
int numSubarrays = subarrayTokens.countTokens();
// 請注重，"fields[i]" 只是表示數組對象的元數據域。
// 我們需要此數組的一個引用，以便為它的元素賦值。
//
// 這樣：
Object array = fields[i].get(applet);
// 如因某種原因已構造了數組，
// 則使它保持原樣。
//
// 否則：以適當的類型構造數組，
// 並為其分配足夠的內存空間，
// 以容納 HTML 作者提供的全部行。
//
// 請注重，此處的變量 "array" 必定是數組的數組。
// 因此“適當的類型”必定是數組類型。
if (array == null) {
// 構造類型為 componentType 的數組，
// 並為 numSubarrays 行分配內存空間。
fields[i].set(applet, Array.newInstance(componentType, numSubarrays));
// 獲取剛構造的數組的數組的引用。
array = fields[i].get(applet);
}
// 依次對每個子數組進行初始化。
// 請注重，我們確保索引不超出范圍。
// 可能是為數組分配的空間不足，
// 以致無法容納 HTML 作者提供的所有行。
for (int j = 0; j < Array.getLength(array) && j < numSubarrays; j++) {
// 用 StringTokenizer 分析由 HTML 作者提供的行元素。
StringTokenizer elementTokens = new StringTokenizer(subarrayTokens.nextToken());
int numElements = elementTokens.countTokens();
// 引入此新變量的唯一目的就是使代碼更易於閱讀。
// 但稍後我們就會看到這引起了敏感的爭論。 Object subArray = ((Object[])array)[j];
// 如因某種原因已構造了子數組，
// 則使它保持原樣。
//
// 否則：以適當的類型構造子數組，並為其分配充足的內存空間，
// 以便容納由 HTML 作者提供的全部元素。
if (subArray == null) {
// "componentType" 是 "array" 的類型，因此子數組的類型 "componentType.getComponentType()" 的數組即為 "subArray" 的類型。
subArray = Array.newInstance(componentType.getComponentType(), numElements);
}
// 下面的語句是必要的。在前面的條件語句中，
// 可能已為 "subarray" 分配了一個不同於
// "((Object[]array)[j]" 的對象引用。
// 這樣就為這兩個變量重新分配的別名。
// 這樣就確保應用於子數組的全部變化
// 將在子數組的數組（即 "array"）中得到反映。
((Object[])array)[j] = subArray;
// 用 elementTokens 中包含的元素填充子數組。
fillOneDimensionalArray(subArray, elementTokens);
}
}
}
}
catch (Exception e) {
System.err.println(e + " while initializing " + fields[i]);
}
}
}
}
當 type 為 {void.class, boolean.class, byte.class, short.class, int.class, long.class, float.class, double.class} 之一時，type.isPrimitive() 方法即返回 "true"。
分配數組的類反射方法如下所示：
bazField.set(fooObject, Array.newInstance(componentType, numElements));
這將創建數組並為其分配存儲空間，然後用該數組為由變量 bazField 表示且屬於變量 fooObject 的域賦值。換句話說，fooObject 類的 FooClass 有一個由 bazField 表示的屬性，同時我們用這個數組為 FooClass 的 fooObject 實例中的相應域賦值。
以下語句的語法和語義都可能令您吃驚。
Object subArray = ((Object[])array)[j];
該語句的目的是從名為 array 的二維數組中提取第 j 行。我們將該行存儲在變量 subArray 中。這個變量的類型 Object，因為我們預先不知道要處理的一維數組為何種類型；回憶一下前面關於數組的討論，任何類型的一維數組的最近公共超類即 Object 類。若不是另有原因，該變量數組的類型也是 Object。我們預先不知道要處理的是基本類型的一維數組，還是其他類型的數組，同樣，最近的公共超類仍是 Object。當我們看到這條語句時，我們已經知道了這樣一個事實：變量 array 表示一個二維數組；回憶一下我們關於數組的討論，二維數組實際上是一維數組的一維數組。因此，它們實際上都是 Object[] 的子類。這就是我們能將變量 array 轉換為 Object[] 的原因所在。接下來的工作就很簡單了，提取第 j 行作為 Object 實例，並將其賦給變量 subArray。
小結
本技巧說明了如何利用類反射機制來減輕程序員開發可配置 applet 的負擔。本月的這篇技巧用數組提取例程對我們的技術作了補充。通過使用一個完成所有參數提取工作的方法，您就免除了不得不一再輸入 getParameter 的乏味工作。
作者簡介
yvon.sauvageau Yvon 獲得了 McGill 大學（位於加拿大蒙特利爾市）的數學及計算機科學學位。他有七年的編程經驗，范圍涉及商業服務器應用程序到 GUI 編程。兩年前他迷上了 Java（沒辦法！）。他去年一月份通過了 Sun 認證 Java 程序員考試，最近又通過了 Sun 認證 Java 開發員考試。他目前是巴黎 MTLI-NSK 技術公司的一名咨詢人員。他目前承擔的項目是一個人力資源治理系統，該系統完全用 Java 編寫，並且基於 ObjectStore OODBMS。在歐洲的生活很有樂趣，但作為加拿大人他很想念曲棍球！
參考資源
下面是本技巧的源代碼（zip 格式）：
javatip59.zip
下面是本技巧的源代碼（jar 格式）：
javatip59.jar
請參閱我的上一篇技巧，"Java Tip 57: Applet parameterization via class reflection"
http://www.javaworld.com/javatips/jw-javatip57.html
有關類反射的信息，請參閱 ChUCk McManis 在 JavaWorld 發表的文章，"Take an in-depth look at the Java Reflection API"
http://www.javaworld.com/javaworld/jw-09-1997/jw-09-indepth.html
