注意：如果你熟悉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[i];
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[i][j] = k;
k++;
}
for(i=0; i<4; i++) {
for(j=0; j<5; j++)
System.out.print(twoD[i][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
k++;
}
for(i=0; i<4; i++) {for(j=0; j
该程序产生的输出如下：
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[i][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[i][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[i][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];
包含这种数组声明格式主要是为了方便。