Java之五 数组

    一维数组的声明和定义

    一维数组的应用

视频课堂：https://edu.csdn.net/course/play/8222

一维数组（one-dimensional array）实质上是相同类型变量列表。要创建一个数组，你必须首先定义数组变量所需的类型。通用的一维数组的声明格式是：

typevar-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 aone-dimensional array.
class Array {
　　publicstatic 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[]) {
　　intmonth_days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
　　System.out.println("Aprilhas " + 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);

}

}

在Java中，多维数组（multidimensionalarrays）实际上是数组的数组。你可能期望，这些数组形式上和行动上和一般的多维数组一样。然而，你将看到，有一些微妙的差别。定义多维数组变量要将每个维数放在它们各自的方括号中。例如，下面语句定义了一个名为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 differingsize second dimensions.

class TwoDAgain {

public static void main(Stringargs[]) {

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<i+1; j++) {

twoD[i][j] = k;

k++;

}

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

for(j=0; j<i+1; j++)

System.out.print(twoD[i][j] +" ");

System.out.println();

}

}

}

该程序产生的输出如下：

0

1 2

3 4 5

6 7 8 9

该程序定义的数组可以表示如下：

对于大多数应用程序，我们不推荐使用不规则多维数组，因为它们的运行与人们期望的相反。但是，不规则多维数组在某些情况下使用效率较高。例如，如果你需要一个很大的二维数组，而它仅仅被稀疏地占用（即其中一维的元素不是全被使用），这时不规则数组可能是一个完美的解决方案。

初始化多维数组是可能的。初始化多维数组只不过是把每一维的初始化列表用它自己的大括号括起来即可。下面的程序产生一个矩阵，该矩阵的每个元素包括数组下标的行和列的积。同时注意在数组的初始化中你可以像用字面量一样用表达式。

// Initialize atwo-dimensional array.

class Matrix {

public static void main(Stringargs[]) {

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 athree-dimensional array.

class threeDMatrix {

public static void main(Stringargs[]) {

int threeD[][][] = newint[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

1. 思考现实生活中，我们有没有处理过一组相同的类型数据的概念？

2. 如果你学过数学上矩阵的概念，那么它与多维数组的关系如何？

在本章中，我们主要学习了：

u      数组的声明、定义、使用；

u      一维数组和多维数组的应用；

英文            全文                                 中文

Array      Array                数组

现在有两个箱子，一个箱子里放只能放鸡蛋。另一个箱子里只能放番茄。两个箱子里原来有8个鸡蛋和12个番茄。用面向对象的编程思想，并结合数组的概念实现箱子的初始化及往箱子里添加鸡蛋和番茄的程序；

文章来源: aaaedu.blog.csdn.net，作者：tea_year，版权归原作者所有，如需转载，请联系作者。

原文链接：aaaedu.blog.csdn.net/article/details/51469921