JAVA数组 第一篇：二维、多维数组的两种输入方法；二维、多维数组的复制

数组本身就是一种数据类型，它用以存储数据。数组可以存储的数据类型有：int型、double型、char型等等不同的基本数据类型。但一个数组只能存储一种数据类型。

二维数组是我们经常接触到的数组，多维数组我们有时也会接触。

在此我以int型数据类型作为实例讲解二维数组、多维数组的输入方法以及数组的复制。

（一）、数组的输入：

数组的输入输出方法我们一般有两种，一种是在main()方法中定义一个数组，然后将其输出，还有一种是利用控制台输入数组，再将其输出。

A、main()方法操作

我们在main()方法中输入如下代码：

		int a[] = new int[] { 1, 2, 5, 4, 3 };
		System.out.println(Arrays.toString(a));

		int[][] array = new int[][] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };
		System.out.println(Arrays.deepToString(array));

运行结果：

[1, 2, 5, 4, 3]

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

Arrays类中提供了将数组转换为String类型输出的方法，这种方法能够让数组元素以数据“集合”的方式输出，而不用以元素方式一个一个地输出，但二维数组采用的是toString()方法，而多维数组采用的是deepToString()方法。

B、控制台操作

控制台输入法我们一般调用Scanner()类，然后利用for() { }循环控制。

我们在main()方法中输入如下代码：

		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数组的元素个数：");
		int count = scanner.nextInt();

		int a[] = new int[count];
		System.out.println("请输入数组元素：");
		for (int b = 0; b < count; b++) {
			a[b] = scanner.nextInt();
		}
		System.out.println(Arrays.toString(a));

在控制台中我们根据提示进行操作，最后控制台中会显示我们的输入信息以及通过main()方法执行后的结果：

请输入数列的项数：
5
请输入数组元素：
1
2
5
4
3
[1, 2, 5, 4, 3]

这段代码我们先通过输入的数字确定了这段数组的元素个数，利用元素个数确定数组的长度，然后通过for() { }循环分别向数组中相应的位置赋值，最后再以转换为String类型的数组输出。

这里有一点要注意，数组是从“位置1”开始计数的，而JAVA语言是从“位置0”开始计数的，因此数组{1,2,3,4,……,n}在JAVA语言中应当转换为数组{0,1,2,3,……,n-1}，否则会报错。

这是二维数组的输入方式，多维数组稍有不同。

多维数组也可以通过控制台输入，但每一维的数组长度都要定义。

		Scanner scanner = new Scanner(System.in);

		System.out.println("请输入数组的组数：");
		int lengthHang = scanner.nextInt();
		System.out.println("请输入每组数组的元素个数：");
		int lengthLie = scanner.nextInt();

		int[][] array = new int[lengthHang][lengthLie];
		System.out.println("请输入数组元素：");
		for (int a = 0; a < lengthHang; a++) {
			for (int b = 0; b < lengthLie; b++) {
				array[a][b] = scanner.nextInt();
			}
		}

		System.out.println(Arrays.deepToString(array));

 

在控制台中我们同样根据提示进行操作，最后控制台中会显示我们的输入信息以及通过main()方法执行后的结果：

请输入数组的组数：
3
请输入每组数组的元素个数：
4
请输入数组元素：
1
2
3
4
5
6
7
8
9
10
11
12
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

 

我们来观察这两种数组，可以看得出来，二维数组的定义方式为：数组名[元素个数]，多维数组的定义方式为：数组名[数组组数][元素个数]。

（二）、数组的复制

我们依旧使用上述两个数组：

		int a[] = new int[] { 1, 2, 5, 4, 3 };
		int[][] array = new int[][] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };

我们先来看看二维数组的复制：

我们在main()方法中输入如下代码：

		int a[] = new int[] { 1, 2, 5, 4, 3 };
		System.out.println(Arrays.toString(a));
		int d[] = Arrays.copyOf(a, 0);
		System.out.println("Arrays.copyOf(a, 0) : " + Arrays.toString(d));
		d = Arrays.copyOf(a, 1);
		System.out.println("Arrays.copyOf(a, 1) : " + Arrays.toString(d));
		d = Arrays.copyOf(a, a.length - 2);
		System.out.println("Arrays.copyOf(a, a.length - 2) : " + Arrays.toString(d));
		d = Arrays.copyOf(a, a.length - 1);
		System.out.println("Arrays.copyOf(a, a.length - 1) : " + Arrays.toString(d));
		d = Arrays.copyOf(a, a.length);
		System.out.println("Arrays.copyOf(a, a.length) : " + Arrays.toString(d));
		d = Arrays.copyOf(a, a.length + 1);
		System.out.println("Arrays.copyOf(a, a.length + 1) : " + Arrays.toString(d));
		d = Arrays.copyOf(a, a.length + 2);
		System.out.println("Arrays.copyOf(a, a.length + 2) : " + Arrays.toString(d));

		d = Arrays.copyOfRange(a, 0, a.length);
		System.out.println("Arrays.copyOfRange(a, 0, a.length) : " + Arrays.toString(d));
		d = Arrays.copyOfRange(a, 2, a.length);
		System.out.println("Arrays.copyOfRange(a, 2, a.length) : " + Arrays.toString(d));
		d = Arrays.copyOfRange(a, 1, a.length - 2);
		System.out.println("Arrays.copyOfRange(a, 1, a.length - 2) : " + Arrays.toString(d));
		d = Arrays.copyOfRange(a, 1, a.length + 2);
		System.out.println("Arrays.copyOfRange(a, 1, a.length + 2) : " + Arrays.toString(d));

运行结果：

[1, 2, 5, 4, 3]
Arrays.copyOf(a, 0) : []
Arrays.copyOf(a, 1) : [1]
Arrays.copyOf(a, a.length - 2) : [1, 2, 5]
Arrays.copyOf(a, a.length - 1) : [1, 2, 5, 4]
Arrays.copyOf(a, a.length) : [1, 2, 5, 4, 3]
Arrays.copyOf(a, a.length + 1) : [1, 2, 5, 4, 3, 0]
Arrays.copyOf(a, a.length + 2) : [1, 2, 5, 4, 3, 0, 0]

Arrays.copyOfRange(a, 0, a.length) : [1, 2, 5, 4, 3]
Arrays.copyOfRange(a, 2, a.length) : [5, 4, 3]
Arrays.copyOfRange(a, 1, a.length - 2) : [2, 5]
Arrays.copyOfRange(a, 1, a.length + 2) : [2, 5, 4, 3, 0, 0]

我们先来观察上半部分的代码和运行结果，数组复制的语法为：Arrays.copyOf(原数组, 新长度);。它以原数组及其长度（元素个数）为基础：新长度为0，输出空数组；不超过其长度的新数组“符合”原数组的“输出规矩”，从原数组“1号”元素开始，直至输完新长度的元素为止；超过其长度的新数组将原数组输出之后，再以0逐个补全超过原长度的每个号（位置），当然不同的数据类型会以不同的方式补全。

我们再来观察下半部分的代码和运行结果，数组复制的语法为：Arrays.copyOfRange(原数组, 起始位置, 终止位置)，它与上述复制方法是有所区别的，上半部分的新长度其实是“元素个数”，新的非空数组的起始位置为1；而下半部分的起始位置是从0开始计算的，它从起始位置开始输出，输出的个数为（终止位置 - 起始位置），超出的部分同样以0补全。

多维数组的复制：

		int[][] a = new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
		System.out.println(Arrays.deepToString(a));
		int d[][] = Arrays.copyOf(a, 0);
		System.out.println("Arrays.copyOf(a, 0) : " + Arrays.deepToString(d));
		d = Arrays.copyOf(a, 1);
		System.out.println("Arrays.copyOf(a, 1) : " + Arrays.deepToString(d));
		d = Arrays.copyOf(a, a.length - 2);
		System.out.println("Arrays.copyOf(a, a.length - 2) : " + Arrays.deepToString(d));
		d = Arrays.copyOf(a, a.length - 1);
		System.out.println("Arrays.copyOf(a, a.length - 1) : " + Arrays.deepToString(d));
		d = Arrays.copyOf(a, a.length);
		System.out.println("Arrays.copyOf(a, a.length) : " + Arrays.deepToString(d));
		d = Arrays.copyOf(a, a.length + 1);
		System.out.println("Arrays.copyOf(a, a.length + 1) : " + Arrays.deepToString(d));
		d = Arrays.copyOf(a, a.length + 2);
		System.out.println("Arrays.copyOf(a, a.length + 2) : " + Arrays.deepToString(d));
		d = Arrays.copyOfRange(a, 1, 1);
		System.out.println("Arrays.copyOfRange(a, 1, 1) : " + Arrays.deepToString(d));
		d = Arrays.copyOfRange(a, 1, 2);
		System.out.println("Arrays.copyOfRange(a, 1, 2) : " + Arrays.deepToString(d));
		d = Arrays.copyOfRange(a, 1, 3);
		System.out.println("Arrays.copyOfRange(a, 1, 3) : " + Arrays.deepToString(d));
		d = Arrays.copyOfRange(a, 1, 4);
		System.out.println("Arrays.copyOfRange(a, 1, 4) : " + Arrays.deepToString(d));

运行结果：

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Arrays.copyOf(a, 0) : []
Arrays.copyOf(a, 1) : [[1, 2, 3]]
Arrays.copyOf(a, a.length - 2) : [[1, 2, 3]]
Arrays.copyOf(a, a.length - 1) : [[1, 2, 3], [4, 5, 6]]
Arrays.copyOf(a, a.length) : [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Arrays.copyOf(a, a.length + 1) : [[1, 2, 3], [4, 5, 6], [7, 8, 9], null]
Arrays.copyOf(a, a.length + 2) : [[1, 2, 3], [4, 5, 6], [7, 8, 9], null, null]
Arrays.copyOfRange(a, 1, 1) : []
Arrays.copyOfRange(a, 1, 2) : [[4, 5, 6]]
Arrays.copyOfRange(a, 1, 3) : [[4, 5, 6], [7, 8, 9]]
Arrays.copyOfRange(a, 1, 4) : [[4, 5, 6], [7, 8, 9], null]

我们先来观察上半部分的代码和运行结果，数组复制的语法为：Arrays.copyOf(原数组, 新长度);。它以原数组及其长度（数组组数）为基础：新长度为0，输出空数组；不超过其长度的新数组“符合”原数组的“输出规矩”，从原数组“1号小组”元素开始，直至输完新长度的组数为止；超过其长度的新数组将原数组输出之后，再以null逐个补全超过原长度的每个号（小组）。二维数组以元素为单位，所以用0补全，多维数组中以小组为单位，所以是用null而不是用0补全。

我们再来观察下半部分的代码和运行结果，数组复制的语法为：Arrays.copyOfRange(原数组, 起始位置, 终止位置)，它与上述复制方法是有所区别的，上半部分的新长度其实是“组数”，新的非空数组的起始位置为1；而下半部分的起始位置是从0开始计算的，它从起始位置开始输出，输出的组数为（终止位置 - 起始位置），超出的部分同样以null补全。