Java数组

数组是一种数据结构，用来存储同一类型值的结合。通过整型的下标可以索引取得数组中的每一个值。

一、数组的声明

　　a) 数组的声明方式，有两种：

  1. dataType[] arrName;
  2. dataType arrName[];

　　b)  示例：

?
1
2
int[] array;
int array[];

　　注意: 建议使用dataType[] arrName;的声明风格声明数组变量。上面的语句只是声明了一个某种类型的数组的变量，但是并没有初始化为一个真正的数组。

 

二、数组的创建

　　Java语言使用new运算符进行数组的创建。通过new创建的数组就是一个真正的数组了。

  • 语法格式：dataType[] arrName = new dataType[arraySize];
  • 数组的初始化值：
  1. 对于数值数组，数组的初始化值为 0
  2. 对于布尔数组，数组的初始化值为 false
  3. 对于对象数组，数组的初始化值为 null
  4. 对于字符串数组，数组的初始化值也为 null
  • 程序示例：
?
1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
　　// 数组的声明方式：
　　// int[] array;
　　int[] array1 = new int[1];
　　Object[] array2 = new Object[1];
　　boolean[] array3 = new boolean[1];
　　String[] array4 = new String[1];
　　System.out.println("int[] 初始值： " + array1[0]);
　　System.out.println("Object[] 初始值： " + array2[0]);
　　System.out.println("boolean[] 初始值： " + array3[0]);
　　System.out.println("String[] 初始值： " + array4[0]);
}　

　　

  • 一旦创建了数组，那么数组的大小就固定了，数组的大小是不能改变的。
  • 通过arrayName.length可以取得数组的元素的个数
?
1
2
3
4
public static void main(String[] args) {
    int[] array = new int[10];
    System.out.println("int[] 的元素个数为： " + array.length);
}

 

 

三、数组的初始化

　　当数组没有显示的初始化的时候，数组会有一个默认的初始值，见二。数组的显示初始化有如下几种方式：

  1. 直接初始化： dataType[] arrayName = {arrayElemts........};
  2. 用一个数组初始化另一个数组：
?
1
2
Int[] arr = {1,2,3,4,5,6};
Int[] array = arr;

　　 3. 匿名数组初始化：

?
1
arrayName = new dataType[]{a,b,c,d};

　　最后两种初始化的方式其实就是相当于引用对象，指向的是同一个地方。它们的地址值是一样的。图解见下：

  

 

四、数组的拷贝

　　在Java中允许将一个数组变量拷贝给另一个数组变量，主要是通过Arrays类的copyOf函数实现，见下代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Test1 {
　　public static void main(String[] args) {
　　// 创建并初始化一个数组
　　int[] array = new int[] { 1, 2, 3, 4, 5, 6, 7 };
　　// 将array数组拷贝给copyArr数组
　　int[] copyArr = Arrays.copyOf(array, array.length);
　　// 打印array数组
　　System.out.print("array数组： ");
　　printArr(array);
　　// 打印copyArr数组
　　System.out.print("copyArr数组： ");
　　printArr(copyArr);
　　System.out.println("array数组的地址值：" + array);
　　System.out.println("array数组的地址值：" + copyArr);
}
 
public static int printArr(int[] array) {
　　if (array == null) {
　　　　　　return -1;
　　}
　　// 打印数组
　　System.out.print("[");
　　for (int i = 0; i < array.length; i++) {
　　　　if (i == array.length - 1) {
　　　　　　System.out.print(array[i] + "]");
　　　　} else {
　　　　System.out.print(array[i] + ",");
　　　　}
　　}
　　System.out.println();
　　return 1;
　}
}

　　

　　从上运行结果可以分析出，通过Arrays类的copyOf方法的确能把数组进行复制，且通过分别打印原数组和复制数组的地址，发现这是两个不同的地址，这就说明了此数组的复制，是一份完全的拷贝，而不是将引用指向原数组。

　　数组拷贝图解：

　　 

 

五、数组的遍历

　　数组的遍历有两种方式，一种是普通for循环遍历，还有一种是增强for循环遍历，下面将用两种方式的代码演示：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class Test1 {
　　public static void main(String[] args) {
　　　　// 创建并初始化一个数组
　　　　int[] array = new int[] { 1, 2, 3, 4, 5, 6, 7 };
　　　　System.out.print("普通for遍历： ");
　　　　visitArray1(array);
　　　　System.out.print("增强for遍历： ");
　　　　visitArray2(array);
　　}
 
　　// 普通for遍历
　　public static int visitArray1(int[] array) {
　　　　if (array == null) {
　　　　　　return -1;
　　　　}
 
　　　　// 打印数组
　　　　System.out.print("[");
　　　　for (int i = 0; i < array.length; i++) {
　　　　　　if (i == array.length - 1) {
　　　　　　　　System.out.print(array[i] + "]");
　　　　　　} else {
　　　　　　　　System.out.print(array[i] + ",");
　　　　　　}
　　　　}
　　System.out.println();
　　return 1;
} // 增强for遍历
　　public static int visitArray2(int[] array) {
　　　　if (array == null) {
　　　　　　return -1;
　　　　}
　　　　// 打印数组
　　　　System.out.print("[");
　　　　int i = 0;
　　　　for (int element : array) {
　　　　　　if (i == array.length - 1) {
　　　　　　　　System.out.print(element);
　　　　　　} else {
　　　　　　　　System.out.print(element + ",");
　　　　　　}
　　　　　　i++;
　　　　}
　　　　System.out.print("]");
　　　　return 1;
　　}
}

　　

 

六、多维数组

  • 多维数组将使用多个下标访问数组元素，它使用于表示表格或者更加复杂的排列方式。
  • 多维数组的声明和创建还有遍历基本上和一维数组一致，见下格式：
  1. 多维数组声明：dataType[][] arrayName;
  2. 多维数组创建：arrayName = new dataType[rowSize][colSize];
  3. 多维数组的初始化:dataType[][] arrayName = {{....},{....},....};
  4. 多维数组的遍历，同样有两种方式普通for和增强for，这里演示增强for的代码，见下示例代码（以二维数组为例）：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Test2 {
　　public static void main(String[] args) {
　　　　// 创建一个二维数组
　　　　Random random = new Random();
　　　　int[][] twoArr = new int[6][6];
　　　　// 普通for为二维数组赋值
　　　　for (int i = 0; i < twoArr.length; i++) {
　　　　　　for (int j = 0; j < twoArr.length; j++) {
　　　　　　　　twoArr[i][j] = random.nextInt(50);
　　　　　　}
　　　　}
　　　　System.out.println("二维数组的比遍历： ");
　　　　// 遍历数组
　　　　visitTwoArr(twoArr);
　　}
　　public static int visitTwoArr(int[][] arr) {
　　　　if (arr == null) {
　　　　　　return -1;
　　　　}
　　　　for (int[] array : arr) {
　　　　　　for (int element : array) {
　　　　　　　　System.out.print(element + "\t");
　　　　　　}
　　　　　　System.out.println();
　　　　}
　　　　return 0;
　　}
}

　　

 

　　>>>>.二维数组的示意图：

　　 

 

七、不规则数组 

 　　通过上面二维数组的图解，知道二维数组是一个一维数组中保存着另外一个数组所形成的一张表状的数组。当我们将存在一维数组中每个数组的长度设为不同的值，那么就形成了一个不规则的数组。如下图：

  

　　a)  代码演示创建和遍历

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Test3 {
　　private static final int rowSize = 5;
　　public static void main(String[] args) {
　　Random random = new Random();
　　// 定义一个不规则的数组
　　int[][] array = new int[rowSize][];
　　// 给二维数组确定不同的长度
　　for (int i = 0; i < array.length; i++) {
　　　　array[i] = new int[random.nextInt(5)];
　　}
　　// 为不规则数组赋值
　　for (int i = 0; i < array.length; i++) {
　　　　for (int j = 0; j < array[i].length; j++) {
　　　　　　array[i][j] = random.nextInt(50);
　　　　}
　　}
　　// 遍历不规则数组
　　for (int[] arr : array) {
　　　　for (int element : arr) {
　　　　　　System.out.print(element + "\t");
　　　　}
　　　　System.out.println();
　　}
　　}
}

　　

posted @   Geore  阅读(177)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示