数组是有序数据的集合，数组中的每个元素具有相同的数组名和下标来唯一地确定数组中的元素。
1. 一维数组
1.1 一维数组的定义
type arrayName[];
type[] arrayName;其中类型(type)可以为Java中任意的数据类型，包括简单类型组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。
第二种形式对C++开发者可能觉得很奇怪，不过对JAVA或C#这样的开发语言来说，第二种形式可能更直观，因为这里定义的只是个变量而已，系统并未对其实例化，只需指明变量的类型即可，也不需在[]指定数组大小。(第一种形式是不是只是为了兼容以前的习惯，毕竟C语言的影响太大了？)
例如：
int intArray[];声明了一个整型数组，数组中的每个元素为整型数据。与C、C++不同，Java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度，而且对于如上定义的一个数组是不能访问它的任何元素的。我们必须为它分配内存空间，这时要用到运算符new，其格式如下：
arrayName=new type[arraySize];其中，arraySize指明数组的长度。如：
intArray=new int[3];为一个整型数组分配3个int型整数所占据的内存空间。
通常，这两部分可以合在一起，格式如下：
type arrayName=new type[arraySize];例如：
int intArray=new int[3];1.2 一维数组元素的引用
定义了一个数组，并用运算符new为它分配了内存空间后，就可以引用数组中的每一个元素了。数组元素的引用方式为：
arrayName[index]其中：index为数组下标，它可以为整型常数或表达式。如a[3]，b[i](i为整型)，c[6*I]等。下标 从0开始，一直到数组的长度减1。对于上面例子中的in-tArray数来说，它有3个元素，分别为：
intArray[0]，intArray[1]，intArray[2]。注意：没有intArray[3]。
另外，与C、C++中不同，Java对数组元素要进行越界检查以保证安全性。同时，对于每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。
运行结果如下：
public class ArrayTest {
public static void main(String args[]){
int i;
int a[]= new int[5];
int b[] = {1,2,3,4,5};
int[] c = new int[5];
int[] d = {1,2,3,4,5};
for(i=0;i<5;i++)
a[i] = i;
for(i=0;i<5;i++)
c[i] = i;
for(i=a.length-1;i>=0;i--)
System.out.println("a["+i+"]="+a[i]);
for(i=b.length-1;i>=0;i--)
System.out.println("b["+i+"]="+b[i]);
for(i=c.length-1;i>=0;i--)
System.out.println("c["+i+"]="+c[i]);
for(i=d.length-1;i>=0;i--)
System.out.println("d["+i+"]="+d[i]);
}
}C:/＞java ArrayTest
a[4]=4
a[3]=3
a[2]=2
a[1]=1
a[0]=0
b[4]=5
b[3]=4
b[2]=3
b[1]=2
b[0]=1
c[4]=4
c[3]=3
c[2]=2
c[1]=1
c[0]=0
d[4]=5
d[3]=4
d[2]=3
d[1]=2
d[0]=1该程序对数组中的每个元素赋值，然后按逆序输出。
1.3 一维数组的初始化
对数组元素可以按照上述的例子进行赋值。也可以在定义数组的同时进行初始化。
例如：
int a[]={1，2，3，4，5};用逗号(，)分隔数组的各个元素，系统自动为数组分配一定空间。
与C中不同，这时Java不要求数组为静态(static)，其实这里的变量类似C中的指针，所以将其作为返回值给其它函数使用，仍然是有效的，在C中将局部变量返回给调用函数继续使用是初学者很容易犯的错误。
2. 多维数组
与C、C++一样，Java中多维数组被看作数组的数组。例如二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。下面我们主要以二维数为例来进行说明，高维的情况是类似的。
2.1 二维数组的定义
二维数组的定义方式为：
type arrayName[][];
type[][] arrayName;例如：
int intArray[][];
int[][] intArray;与一维数组一样，这时对数组元素也没有分配内存空间，同要使用运算符new来分配内存，然后才可以访问每个元素。
对高维数组来说，分配内存空间有下面几种方法：
1. 直接为每一维分配空间，如：
int a[][]=new int[2][3];2. 从最高维开始，分别为每一维分配空间，如：
int a[][]=new int[2][];
a[0]=new int[3];
a[1]=new int[3];完成1中相同的功能。这一点与C、C++是不同的，在C、C++中必须一次指明每一维的长度。
2.2 二维数组元素的引用
对二维数组中每个元素，引用方式为：arrayName[index1][index2] 其中index1、index2为下标，可为整型常数或表达式，如a[2][3]等，同样，每一维的下标都从0开始。
2.3 二维数组的初始化
有两种方式：
1. 直接对每个元素进行赋值。
2. 在定义数组的同时进行初始化。
如：
int a[][]={{2，3}，{1，5}，{3，4}};定义了一个3×2的数组，并对每个元素赋值。
public class ArrayMoreTest {
public static void main(String args[]){
int i,j;
int[][] e = new int[2][3];
for(i=0;i<2;i++){
for(j=0;j<3;j++){
e[i][j] = i+j;
}
}
for(i=e.length-1;i>=0;i--){
for(j=e[i].length-1;j>=0;j--){
System.out.println("e["+i+"]["+j+"]=" +e[i][j]);
}
}
}
}运行结果如下：
e[1][2]=3
e[1][1]=2
e[1][0]=1
e[0][2]=2
e[0][1]=1
e[0][0]=0
数组是有序数据的集合，数组中的每个元素具有相同的数组名和下标来唯一地确定数组中的元素。
1. 一维数组
1.1 一维数组的定义
type arrayName[];
type[] arrayName;其中类型(type)可以为Java中任意的数据类型，包括简单类型组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。
第二种形式对C++开发者可能觉得很奇怪，不过对JAVA或C#这样的开发语言来说，第二种形式可能更直观，因为这里定义的只是个变量而已，系统并未对其实例化，只需指明变量的类型即可，也不需在[]指定数组大小。(第一种形式是不是只是为了兼容以前的习惯，毕竟C语言的影响太大了？)
例如：
int intArray[];声明了一个整型数组，数组中的每个元素为整型数据。与C、C++不同，Java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度，而且对于如上定义的一个数组是不能访问它的任何元素的。我们必须为它分配内存空间，这时要用到运算符new，其格式如下：
arrayName=new type[arraySize];其中，arraySize指明数组的长度。如：
intArray=new int[3];为一个整型数组分配3个int型整数所占据的内存空间。
通常，这两部分可以合在一起，格式如下：
type arrayName=new type[arraySize];例如：
int intArray=new int[3];1.2 一维数组元素的引用
定义了一个数组，并用运算符new为它分配了内存空间后，就可以引用数组中的每一个元素了。数组元素的引用方式为：
arrayName[index]其中：index为数组下标，它可以为整型常数或表达式。如a[3]，b[i](i为整型)，c[6*I]等。下标 从0开始，一直到数组的长度减1。对于上面例子中的in-tArray数来说，它有3个元素，分别为：
intArray[0]，intArray[1]，intArray[2]。注意：没有intArray[3]。
另外，与C、C++中不同，Java对数组元素要进行越界检查以保证安全性。同时，对于每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。
运行结果如下：
public class ArrayTest {
public static void main(String args[]){
int i;
int a[]= new int[5];
int b[] = {1,2,3,4,5};
int[] c = new int[5];
int[] d = {1,2,3,4,5};
for(i=0;i<5;i++)
a[i] = i;
for(i=0;i<5;i++)
c[i] = i;
for(i=a.length-1;i>=0;i--)
System.out.println("a["+i+"]="+a[i]);
for(i=b.length-1;i>=0;i--)
System.out.println("b["+i+"]="+b[i]);
for(i=c.length-1;i>=0;i--)
System.out.println("c["+i+"]="+c[i]);
for(i=d.length-1;i>=0;i--)
System.out.println("d["+i+"]="+d[i]);
}
}C:/＞java ArrayTest
a[4]=4
a[3]=3
a[2]=2
a[1]=1
a[0]=0
b[4]=5
b[3]=4
b[2]=3
b[1]=2
b[0]=1
c[4]=4
c[3]=3
c[2]=2
c[1]=1
c[0]=0
d[4]=5
d[3]=4
d[2]=3
d[1]=2
d[0]=1该程序对数组中的每个元素赋值，然后按逆序输出。
1.3 一维数组的初始化
对数组元素可以按照上述的例子进行赋值。也可以在定义数组的同时进行初始化。
例如：
int a[]={1，2，3，4，5};用逗号(，)分隔数组的各个元素，系统自动为数组分配一定空间。
与C中不同，这时Java不要求数组为静态(static)，其实这里的变量类似C中的指针，所以将其作为返回值给其它函数使用，仍然是有效的，在C中将局部变量返回给调用函数继续使用是初学者很容易犯的错误。
2. 多维数组
与C、C++一样，Java中多维数组被看作数组的数组。例如二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。下面我们主要以二维数为例来进行说明，高维的情况是类似的。
2.1 二维数组的定义
二维数组的定义方式为：
type arrayName[][];
type[][] arrayName;例如：
int intArray[][];
int[][] intArray;与一维数组一样，这时对数组元素也没有分配内存空间，同要使用运算符new来分配内存，然后才可以访问每个元素。
对高维数组来说，分配内存空间有下面几种方法：
1. 直接为每一维分配空间，如：
int a[][]=new int[2][3];2. 从最高维开始，分别为每一维分配空间，如：
int a[][]=new int[2][];
a[0]=new int[3];
a[1]=new int[3];完成1中相同的功能。这一点与C、C++是不同的，在C、C++中必须一次指明每一维的长度。
2.2 二维数组元素的引用
对二维数组中每个元素，引用方式为：arrayName[index1][index2] 其中index1、index2为下标，可为整型常数或表达式，如a[2][3]等，同样，每一维的下标都从0开始。
2.3 二维数组的初始化
有两种方式：
1. 直接对每个元素进行赋值。
2. 在定义数组的同时进行初始化。
如：
int a[][]={{2，3}，{1，5}，{3，4}};定义了一个3×2的数组，并对每个元素赋值。
public class ArrayMoreTest {
public static void main(String args[]){
int i,j;
int[][] e = new int[2][3];
for(i=0;i<2;i++){
for(j=0;j<3;j++){
e[i][j] = i+j;
}
}
for(i=e.length-1;i>=0;i--){
for(j=e[i].length-1;j>=0;j--){
System.out.println("e["+i+"]["+j+"]=" +e[i][j]);
}
}
}
}运行结果如下：
e[1][2]=3
e[1][1]=2
e[1][0]=1
e[0][2]=2
e[0][1]=1
e[0][0]=0
数组是有序数据的集合，数组中的每个元素具有相同的数组名和下标来唯一地确定数组中的元素。
1. 一维数组
1.1 一维数组的定义
type arrayName[];
type[] arrayName;其中类型(type)可以为Java中任意的数据类型，包括简单类型组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。
第二种形式对C++开发者可能觉得很奇怪，不过对JAVA或C#这样的开发语言来说，第二种形式可能更直观，因为这里定义的只是个变量而已，系统并未对其实例化，只需指明变量的类型即可，也不需在[]指定数组大小。(第一种形式是不是只是为了兼容以前的习惯，毕竟C语言的影响太大了？)
例如：
int intArray[];声明了一个整型数组，数组中的每个元素为整型数据。与C、C++不同，Java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度，而且对于如上定义的一个数组是不能访问它的任何元素的。我们必须为它分配内存空间，这时要用到运算符new，其格式如下：
arrayName=new type[arraySize];其中，arraySize指明数组的长度。如：
intArray=new int[3];为一个整型数组分配3个int型整数所占据的内存空间。
通常，这两部分可以合在一起，格式如下：
type arrayName=new type[arraySize];例如：
int intArray=new int[3];1.2 一维数组元素的引用
定义了一个数组，并用运算符new为它分配了内存空间后，就可以引用数组中的每一个元素了。数组元素的引用方式为：
arrayName[index]其中：index为数组下标，它可以为整型常数或表达式。如a[3]，b[i](i为整型)，c[6*I]等。下标 从0开始，一直到数组的长度减1。对于上面例子中的in-tArray数来说，它有3个元素，分别为：
intArray[0]，intArray[1]，intArray[2]。注意：没有intArray[3]。
另外，与C、C++中不同，Java对数组元素要进行越界检查以保证安全性。同时，对于每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。
运行结果如下：
public class ArrayTest {
public static void main(String args[]){
int i;
int a[]= new int[5];
int b[] = {1,2,3,4,5};
int[] c = new int[5];
int[] d = {1,2,3,4,5};
for(i=0;i<5;i++)
a[i] = i;
for(i=0;i<5;i++)
c[i] = i;
for(i=a.length-1;i>=0;i--)
System.out.println("a["+i+"]="+a[i]);
for(i=b.length-1;i>=0;i--)
System.out.println("b["+i+"]="+b[i]);
for(i=c.length-1;i>=0;i--)
System.out.println("c["+i+"]="+c[i]);
for(i=d.length-1;i>=0;i--)
System.out.println("d["+i+"]="+d[i]);
}
}C:/＞java ArrayTest
a[4]=4
a[3]=3
a[2]=2
a[1]=1
a[0]=0
b[4]=5
b[3]=4
b[2]=3
b[1]=2
b[0]=1
c[4]=4
c[3]=3
c[2]=2
c[1]=1
c[0]=0
d[4]=5
d[3]=4
d[2]=3
d[1]=2
d[0]=1该程序对数组中的每个元素赋值，然后按逆序输出。
1.3 一维数组的初始化
对数组元素可以按照上述的例子进行赋值。也可以在定义数组的同时进行初始化。
例如：
int a[]={1，2，3，4，5};用逗号(，)分隔数组的各个元素，系统自动为数组分配一定空间。
与C中不同，这时Java不要求数组为静态(static)，其实这里的变量类似C中的指针，所以将其作为返回值给其它函数使用，仍然是有效的，在C中将局部变量返回给调用函数继续使用是初学者很容易犯的错误。
2. 多维数组
与C、C++一样，Java中多维数组被看作数组的数组。例如二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。下面我们主要以二维数为例来进行说明，高维的情况是类似的。
2.1 二维数组的定义
二维数组的定义方式为：
type arrayName[][];
type[][] arrayName;例如：
int intArray[][];
int[][] intArray;与一维数组一样，这时对数组元素也没有分配内存空间，同要使用运算符new来分配内存，然后才可以访问每个元素。
对高维数组来说，分配内存空间有下面几种方法：
1. 直接为每一维分配空间，如：
int a[][]=new int[2][3];2. 从最高维开始，分别为每一维分配空间，如：
int a[][]=new int[2][];
a[0]=new int[3];
a[1]=new int[3];完成1中相同的功能。这一点与C、C++是不同的，在C、C++中必须一次指明每一维的长度。
2.2 二维数组元素的引用
对二维数组中每个元素，引用方式为：arrayName[index1][index2] 其中index1、index2为下标，可为整型常数或表达式，如a[2][3]等，同样，每一维的下标都从0开始。
2.3 二维数组的初始化
有两种方式：
1. 直接对每个元素进行赋值。
2. 在定义数组的同时进行初始化。
如：
int a[][]={{2，3}，{1，5}，{3，4}};定义了一个3×2的数组，并对每个元素赋值。
public class ArrayMoreTest {
public static void main(String args[]){
int i,j;
int[][] e = new int[2][3];
for(i=0;i<2;i++){
for(j=0;j<3;j++){
e[i][j] = i+j;
}
}
for(i=e.length-1;i>=0;i--){
for(j=e[i].length-1;j>=0;j--){
System.out.println("e["+i+"]["+j+"]=" +e[i][j]);
}
}
}
}运行结果如下：
e[1][2]=3
e[1][1]=2
e[1][0]=1
e[0][2]=2
e[0][1]=1
e[0][0]=0
