java 陣列(轉)

java 陣列(轉)[@more@]陣列（array）是相同型別變數的集合，可以使用共同的名字引用它。陣列可被定義為任何型別，可以是一維或多維。陣列中的一個特別要素是透過下標來訪問它。陣列提供了一種將有聯絡的資訊分組的便利方法。

注意：如果你熟悉C/C++ ，請注意，Java 陣列的工作原理與它們不同。

3.11.1 一維陣列
一維陣列（one-dimensional array ）實質上是相同型別變數列表。要建立一個陣列，你必須首先定義陣列變數所需的型別。通用的一維陣列的宣告格式是：

type var-name[ ];

其中，type 定義了陣列的基本型別。基本型別決定了組成陣列的每一個基本元素的資料型別。這樣，陣列的基本型別決定了陣列儲存的資料型別。例如，下面的例子定義了資料型別為int ，名為month_days 的陣列。

int month_days[];

儘管該例子定義了month_days 是一個陣列變數的事實，但實際上沒有陣列變數存在。事實上，month_days 的值被設定為空，它代表一個陣列沒有值。為了使陣列month_days 成為實際的、物理上存在的整型陣列，你必須用運算子new 來為其分配地址並且把它賦給month_days 。運算子new 是專門用來分配記憶體的運算子。

你將在後面章節中更進一步瞭解運算子new，但是你現在需要使用它來為陣列分配記憶體。當運算子new被應用到一維陣列時，它的一般形式如下：

array-var = new type[size];

其中，type 指定被分配的資料型別，size指定陣列中變數的個數，array-var 是被連結到陣列的陣列變數。也就是，使用運算子new 來分配陣列，你必須指定陣列元素的型別和陣列元素的個數。用運算子new 分配陣列後，陣列中的元素將會被自動初始化為零。下面的例子分配了一個12個整型元素的陣列並把它們和陣列month_days 連結起來。

month_days = new int[12];

透過這個語句的執行，陣列month_days 將會指向12個整數，而且陣列中的所有元素將被初始化為零。

讓我們回顧一下上面的過程：獲得一個陣列需要2步。第一步，你必須定義變數所需的型別。第二步，你必須使用運算子new來為陣列所要儲存的資料分配記憶體，並把它們分配給陣列變數。這樣Java 中的陣列被動態地分配。如果動態分配的概念對你陌生，別擔心，它將在本書的後面詳細討論。

一旦你分配了一個陣列，你可以在方括號內指定它的下標來訪問陣列中特定的元素。
所有的陣列下標從零開始。例如，下面的語句將值28賦給陣列month_days 的第二個元素。

month_days[1] = 28;

下面的程式顯示儲存在下標為3的陣列元素中的值。

System.out.println ( month_days [ 3 ]);

綜上所述，下面程式定義的陣列儲存了每月的天數。

// Demonstrate a one-dimensional array.

class Array {

public static void main(String args[]) {

int month_days[];

month_days = new int[12];

month_days[0] = 31;

month_days[1] = 28;

month_days[2] = 31;

month_days[3] = 30;

month_days[4] = 31;

month_days[5] = 30;

month_days[6] = 31;

month_days[7] = 31;

month_days[8] = 30;

month_days[9] = 31;

month_days[10] = 30;

month_days[11] = 31;

System.out.println("April has " + month_days[3] + " days.");

}

}

當你執行這個程式時，它列印出4月份的天數。如前面提到的，Java 陣列下標從零開始，因此4月份的天數陣列元素為month_days[3] 或30。

將對陣列變數的宣告和對陣列本身的分配結合起來是可以的，如下所示：

int month_days[] = new int[12];

這將是你通常看見的編寫Java 程式的專業做法。

陣列可以在宣告時被初始化。這個過程和簡單型別初始化的過程一樣。陣列的初始化（array initializer ）就是包括在花括號之內用逗號分開的表示式的列表。逗號分開了陣列元素的值。Java 會自動地分配一個足夠大的空間來儲存你指定的初始化元素的個數，而不必使用運算子new。例如，為了儲存每月中的天數，下面的程式定義了一個初始化的整數陣列：// An improved version of the previous program.

class AutoArray {
public static void main(String args[]) {
int month_days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,
30, 31 };
System.out.println("April has " + month_days[3] + " days.");
}
}

當你執行這個程式時，你會看到它和前一個程式產生的輸出一樣。
Java 嚴格地檢查以保證你不會意外地去儲存或引用在陣列範圍以外的值。Java 的執行系統會檢查以確保所有的陣列下標都在正確的範圍以內（在這方面，Java 與C/C++ 從根本上不同，C/C++ 不提供執行邊界檢查）。例如，執行系統將檢查陣列month_days 的每個下標的值以保證它包括在0和11之間。如果你企圖訪問陣列邊界以外（負數或比陣列邊界大）的元素，你將引起執行錯誤。

下面的例子運用一維陣列來計算一組數字的平均數。

// Average an array of values.
class Average {

public static void main(String args[]) {
double nums[] = {10.1, 11.2, 12.3, 13.4, 14.5};
double result = 0;
int i;

for(i=0; i<5; i++)
result = result + nums;

System.out.println("Average is " + result / 5);
}
}

3.11.2 多維陣列
在Java 中，多維陣列（multidimensional arrays ）實際上是陣列的陣列。你可能期望，這些陣列形式上和行動上和一般的多維陣列一樣。然而，你將看到，有一些微妙的差別。定義多維陣列變數要將每個維數放在它們各自的方括號中。例如，下面語句定義了一個名為twoD 的二維陣列變數。

int twoD[][] = new int[4][5];

該語句分配了一個4行5列的陣列並把它分配給陣列twoD 。實際上這個矩陣表示了int 型別的陣列的陣列被實現的過程。概念上，這個陣列可以用圖3-1 來表示。下列程式從左到右，從上到下為陣列的每個元素賦值，然後顯示陣列的值：


圖3.1 二維陣列（4 行5 列）的概念性表示
// Demonstrate a two-dimensional array.
class TwoDArray {

public static void main(String args[]) {
int twoD[][]= new int[4][5];
int i, j, k = 0;

for(i=0; i<4; i++)

for(j=0; j<5; j++) {
twoD[j] = k;
k++;

}

for(i=0; i<4; i++) {
for(j=0; j<5; j++)
System.out.print(twoD[j] + " ");
System.out.println();
}
}
}

程式執行的結果如下：

0 1 2 3 4
5 6 7 8 9
10 11 12 13 14
15 16 17 18 19

當你給多維陣列分配記憶體時，你只需指定第一個（最左邊）維數的記憶體即可。你可以單獨地給餘下的維數分配記憶體。例如，下面的程式在陣列twoD 被定義時給它的第一個維數分配記憶體，對第二維則是手工分配地址。

int twoD[][] = new int[4][];
twoD[0] = new int[5];
twoD[1] = new int[5];
twoD[2] = new int[5];
twoD[3] = new int[5];

儘管在這種情形下單獨地給第二維分配記憶體沒有什麼優點，但在其他情形下就不同了。例如，當你手工分配記憶體時，你不需要給每個維數相同數量的元素分配記憶體。如前面所說，既然多維陣列實際上是陣列的陣列，每個陣列的維數在你的控制之下。例如，下列程式定義了一個二維陣列，它的第二維的大小是不相等的。

// Manually allocate differing size second dimensions.
class TwoDAgain {

public static void main(String args[]) {
int twoD[][] = new int[4][];
twoD[0] = new int[1];
twoD[1] = new int[2];
twoD[2] = new int[3];
twoD[3] = new int[4];

int i, j, k = 0;

for(i=0; i<4; i++)

for(j=0; j twoD[j] = k;
k++;

}

for(i=0; i<4; i++) {for(j=0; j[j] + " ");System.out.println();}}}

該程式產生的輸出如下：

0 1 2 3 4 5 6 7 8 9

該程式定義的陣列可以表示如下：

對於大多數應用程式，我們不推薦使用不規則多維陣列，因為它們的執行與人們期望的相反。但是，不規則多維陣列在某些情況下使用效率較高。例如，如果你需要一個很大的二維陣列，而它僅僅被稀疏地佔用（即其中一維的元素不是全被使用），這時不規則陣列可能是一個完美的解決方案。

初始化多維陣列是可能的。初始化多維陣列只不過是把每一維的初始化列表用它自己的大括號括起來即可。下面的程式產生一個矩陣，該矩陣的每個元素包括陣列下標的行和列的積。同時注意在陣列的初始化中你可以像用字面量一樣用表示式。

// Initialize a two-dimensional array.

class Matrix {

public static void main(String args[]) {

double m[][] = {

{ 0*0, 1*0, 2*0, 3*0 },

{ 0*1, 1*1, 2*1, 3*1 },

{ 0*2, 1*2, 2*2, 3*2 },

{ 0*3, 1*3, 2*3, 3*3 }};

int i, j;

for(i=0; i<4; i++) {
for(j=0; j<4; j++)
System.out.print(m[j] + " ");
System.out.println();
}
}
}

當你執行這個程式時，你將得到下面的輸出：

0.0 0.0 0.0 0.0

0.0 1.0 2.0 3.0

0.0 2.0 4.0 6.0

0.0 3.0 6.0 9.0

正如你看到，陣列中的每一行就像初始化表指定的那樣被初始化。讓我們再看一個使用多維陣列的例子。下面的程式首先產生一個3×4×5的3維陣列，然後裝入用它的下標之積生成的每個元素，最後顯示了該陣列。

// Demonstrate a three-dimensional array.
class threeDMatrix {

public static void main(String args[]) {
int threeD[][][] = new int[3][4][5];
int i, j, k;

for(i=0; i<3; i++)
for(j=0; j<4; j++)
for(k=0; k<5; k++)
threeD[j][k] = i * j * k;

for(i=0; i<3; i++) {
for(j=0; j<4; j++) {
for(k=0; k<5; k++)
System.out.print(threeD[j][k] + " ");

System.out.println();
}
System.out.println();

}
}
}

該程式的輸出如下：

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12

0 0 0 0 0
0 2 4 6 8
0 4 8 12 16
0 6 12 18 24

3.11.3 另一種陣列宣告語法

宣告陣列還有第二種格式：

type[ ] var-name;

這裡，方括號緊跟在型別識別符號type 的後面，而不是跟在陣列變數名的後面。例如，下面的兩個定義是等價的：

int al[] = new int[3];
int[] a2 = new int[3];

下面的兩個定義也是等價的：

char twod1[][] = new char[3][4];
char[][] twod2 = new char[3][4];

包含這種陣列宣告格式主要是為了方便。