Java中数组的使用

1、复制一个数组句柄

public class Arrays {

	public static void main(String[] args) {
		int[] a1 = {1, 2, 3, 4, 5};
		int[] a2;
		a2 = a1;
		for(int i = 0; i < a2.length; i++) 
			a2[i]++;
		for(int i = 0; i < a1.length; i++) 
			prt("a1[" + i + "] = " + a1[i]);
	}
	static void prt(String s) {
		System.out.println(s);
	}
}

注意：这里真正复制的是一个句柄，所以数组a2改变的时候数组a1也会变化；

运行结果：

这个程序中a1 获得了一个初始值，而a2 没有；a2 将在以后赋值——这种情况下是赋给另一个数组。

2、使用new关键字创建一个基本类型的数组

程序编写期间，如果不知道在自己的数组里需要多少元素，那么又该怎么办呢？此时，只需简单地用new 在
数组里创建元素。在这里，即使准备创建的是一个基本数据类型的数组，new 也能正常地工作（new 不会创建
非数组的基本类型）：

public class ArrayNew {

	static Random rand = new Random();
	static int pRand(int mod) {
		return Math.abs(rand.nextInt()) % mod + 1;
	}
	
	public static void main(String[] args) {
		int[] a;		
		a = new int[pRand(20)];
		prt("length of a = " + a.length);
		for(int i = 0; i < a.length; i++)
			prt("a[" + i + "] = " + a[i]);
	}
	
	static void prt(String s) {
		System.out.println(s);
	}
}

运行结果（数组长度是随机数，每次运行结果不一样）：

由于数组的大小是随机决定的（使用早先定义的pRand()方法），所以非常明显，数组的创建实际是在运行
期间进行的。除此以外，从这个程序的输出中，大家可看到基本数据类型的数组元素会自动初始化成“空”
值（对于数值，空值就是零；对于char，它是null ；而对于boolean，它却是false）。
当然，数组可能已在相同的语句中定义和初始化了，如下所示：
int[] a = new int[pRand(20)];

3、使用new关键字创建一个Integer类型的数组

若操作的是一个非基本类型对象的数组，那么无论如何都要使用new。在这里，我们会再一次遇到句柄问
题，因为我们创建的是一个句柄数组。请大家观察封装器类型Integer，它是一个类，而非基本数据类型：

public class ArrayClassObj {

	static Random rand = new Random();
	static int pRand(int mod) {
		return Math.abs(rand.nextInt()) % mod + 1;
	}
	
	public static void main(String[] args) {
		Integer[] a = new Integer[pRand(20)];
		prt("length of a = " + a.length);
		for(int i = 0; i < a.length; i++) {
			a[i] = new Integer(pRand(500));
			prt("a[" + i + "] = " + a[i]);
		}
	}
	static void prt(String s) {
		System.out.println(s);
	}
}

运行结果：

在这儿，甚至在new 调用后才开始创建数组：
Integer[] a = new Integer[pRand(20)];
它只是一个句柄数组，而且除非通过创建一个新的Integer 对象，从而初始化了对象句柄，否则初始化进程不会结束：
a[i] = new Integer(pRand(500));
但若忘记创建对象，就会在运行期试图读取空数组位置时获得一个“违例”错误。

4、多维数组

import java.util.Random;

public class MultiDimArray {

	static Random rand = new Random();

	static int pRand(int mod) {
		return Math.abs(rand.nextInt()) % mod + 1;
	}

	public static void main(String[] args) {

		int[][] a1 = { { 1, 2, 3, }, { 4, 5, 6, }, };
		for (int i = 0; i < a1.length; i++)
			for (int j = 0; j < a1[i].length; j++)
				prt("a1[" + i + "][" + j + "] = " + a1[i][j]);
		
		// 3-D array with fixed length:
		int[][][] a2 = new int[2][3][4];
		for (int i = 0; i < a2.length; i++)
			for (int j = 0; j < a2[i].length; j++)
				for (int k = 0; k < a2[i][j].length; k++)
					prt("a2[" + i + "][" + j + "][" + k + "]=" + a2[i][j][k]);
	
		// 3-D array with varied-length vectors:
		int[][][] a3 = new int[pRand(7)][][];
		for(int i = 0; i < a3.length; i++) {
			a3[i] = new int[pRand(5)][];
			for(int j = 0; j < a3[i].length; j++)
				a3[i][j] = new int[pRand(5)];
		}
		for (int i = 0; i < a3.length; i++)
			for (int j = 0; j < a3[i].length; j++)
				for (int k = 0; k < a3[i][j].length; k++)
					prt("a3[" + i + "][" + j + "][" + k + "]=" + a3[i][j][k]);
	
		// Array of non-primitive objects:
		Integer[][] a4 = {
				{ new Integer(1), new Integer(2)},
				{ new Integer(3), new Integer(4)},
				{ new Integer(5), new Integer(6)},
		};
		
		for(int i = 0; i < a4.length; i++)
			for(int j = 0; j < a4[i].length; j++)
				prt("a4[" + i + "][" + j +
						"] = " + a4[i][j]);
		
		Integer[][] a5;
		a5 = new Integer[3][];
		for(int i = 0; i < a5.length; i++) {
			a5[i] = new Integer[3];
			for(int j = 0; j < a5[i].length; j++)
				a5[i][j] = new Integer(i*j);
		}
		
		for(int i = 0; i < a5.length; i++)
			for(int j = 0; j < a5[i].length; j++)
				prt("a5[" + i + "][" + j + "] = " + a5[i][j]);
		
	}

	static void prt(String s) {
		System.out.println(s);
	}
}

用于打印的代码里使用了length，所以它不必依赖固定的数组大小。
第一个例子展示了基本数据类型的一个多维数组。我们可用花括号定出数组内每个矢量的边界：
int[][] a1 = {
{ 1, 2, 3, },
{ 4, 5, 6, },
};
每个方括号对都将我们移至数组的下一级。
第二个例子展示了用new 分配的一个三维数组。在这里，整个数组都是立即分配的：
int[][][] a2 = new int[2][2][4];
但第三个例子却向大家揭示出构成矩阵的每个矢量都可以有任意的长度：
int[][][] a3 = new int[pRand(7)][][];

for(int i = 0; i < a3.length; i++) {
a3[i] = new int[pRand(5)][];
for(int j = 0; j < a3[i].length; j++)
a3[i][j] = new int[pRand(5)];
}
对于第一个new 创建的数组，它的第一个元素的长度是随机的，其他元素的长度则没有定义。for 循环内的
第二个new 则会填写元素，但保持第三个索引的未定状态——直到碰到第三个new。
根据输出结果，大家可以看到：假若没有明确指定初始化值，数组值就会自动初始化成零。
可用类似的表式处理非基本类型对象的数组。这从第四个例子可以看出，它向我们演示了用花括号收集多个
new 表达式的能力：
Integer[][] a4 = {
{ new Integer(1), new Integer(2)},
{ new Integer(3), new Integer(4)},
{ new Integer(5), new Integer(6)},
};
第五个例子展示了如何逐渐构建非基本类型的对象数组：

Integer[][] a5;
a5 = new Integer[3][];
for(int i = 0; i < a5.length; i++) {
a5[i] = new Integer[3];
for(int j = 0; j < a5[i].length; j++)
a5[i][j] = new Integer(i*j);
}
i*j 只是在Integer 里置了一个有趣的值。