京东-优惠雷达
新人页面
精选商品
首月0月租体验,领12个月京东PLUS
自营热卖

初始化与清理(5):数组初始化、可变参数列表

拾起回忆 1年前   阅读数 65 0

一、数组初始化

    数组只是相同类型的、用一个标识符名称封装到一起的对象序列或基本类型数据序列。数组是通过方括号下标操作符[]来定义和使用的。要定义一个数组,只需在类型名后加上一对空方括号即可:

int[] a1;

    方括号也可以置于标识符后面:

int a1[];

    两种格式含义是一样的,前一种格式或许更合理,毕竟它表明类型是“一个int型数组”。

    编译器不允许指定数组的大小。这就又把我们带回到有关“引用”的问题上。现在拥有的只是对数组的一个引用(你已经为该引用分配了足够的存储空间),而且也没给数组对象本身分配任何空间。为了给数组创建相应的存储空间,必须写初始化表达式。对于数组,初始化动作可以出现在代码的任何地方,但也可以使用一种特殊的初始化表达式,它必须在创建数组的地方出现。这种特殊的初始化是由一对花括号括起来的值组成的。在这种情况下,存储空间的分配(等价于使用new)将由编译器负责。例如:

int [] a1 = {1, 2, 3, 4, 5};

    那么,为什么还要在没有数组的时候定义一个数组引用呢?int[] a2;在java中可以将一个数组赋值给另一个数组,所以可以这样:a2 = a1;其实真正做的只是复制了一个引用,就像下面演示的那样:

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

    可以看到代码中给出了a1的初始值,但a2却没有;在本例中,a2是在后面被赋给另一个数组的。由于a2和a1是相同数组的别名,因此通过a2所做的修改在a1中可以看到。

    所有数组(无论它们的元素是对象还是基本类型)都有一个固有成员,可以通过它获知数组内包含了多少个元素,但不能对其修改。这个成员就是length。与C和C++类似,java数组计数也是从第0个元素开始,所以能使用的最大下标数是length-1。要是超出这个边界,C和C++会“默默”地接受,并允许你访问所有内存,许多声明狼藉的程序错误由此而生。java则能保护你免受这一问题的困扰,一旦访问下标过界,就会出现运行时错误(即异常)。

    如果在编写程序时,并不能确定数组里需要多少个元素,那么该怎么办呢?可以直接用new在数组里创建元素。尽管创建的是基本类型数组,new仍然可以工作(不能用new创建单个的基本类型数据)。

import java.util.Arrays;
import java.util.Random;

public class ArrayNew {
	public static void main(String[] args) {
		int[] a;
		Random r = new Random();
		a = new int[r.nextInt(20)];
		System.out.println("length of a=" + a.length);
		System.out.println(Arrays.toString(a));
	}
}

    数组的大小是通过r.nextInt()方法随机决定的,这个方法会返回0到输出参数之间的一个值。这表明数组的创建确实是在运行时刻进行的。此外,程序输出表明:数组元素中的基本数据类型值会自动初始化成空值(对于数字和字符,就是0;对于布尔型,是false)。

    Arrrays.toString()方法属于java.util标准类库,它将产生一维数组的可打印版本。

    当然,在本例中,数组也可以在定义的同时进行初始化:

int[] a = new int[r.nextInt(20)];

    如果可能的话,应该尽量这么做。

    如果你创建了一个非基本类型的数组,那么你就创建了一个引用数组。以整型的包装器类Integer为例,它是一个类而不是基本类型:

import java.util.Arrays;
import java.util.Random;

public class ArrayClassObj {
	public static void main(String[] args) {
		Random r = new Random();
		Integer[] a = new Integer[r.nextInt(20)];
		System.out.println("length of a=" + a.length);
		for (int i = 0; i < a.length; i++)
			a[i] = r.nextInt(500);
		System.out.println(Arrays.deepToString(a));
	}
}

    这里,即便使用new创建数组之后:

Integer[] a = new Integer[r.nextInt(20)];

    它还只是一个引用数组,并且直到通过创建新的Integer对象(在本例中是通过自动包装机制创建的),并把对象赋值给引用,初始化进程才算结束:

a[i] = r.nextInt(500);

    如果忘记了创建对象,并且试图使用数组中的空引用,就会在运行时产生异常。

    也可以用花括号括起来的列表来初始化对象数组。有两种形式:

import java.util.Arrays;

public class ArrayInit {
	public static void main(String[] args) {
		Integer[] a = { new Integer(1), new Integer(2), 3 };
		Integer[] b = new Integer[] { new Integer(1), new Integer(2), 3 };
		System.out.println(Arrays.toString(a));
		System.out.println(Arrays.toString(b));
	}
}

    尽管第一种形式很有用,但是它也更加受限,因为它只能用于数组被定义处。你可以在任何地方使用第二种和第三种形式,甚至是在方法调用的内部。例如,你可以创建一个String对象数组,将其传递给另一个main()方法,以提供参数,用来替换传递给该main()方法的命令行参数。

public class DynamicArray {
	public static void main(String[] args) {
		Other.main(new String[] { "fiddle", "de", "dum" });
	}
}

class Other {
	public static void main(String[] args) {
		for (String string : args)
			System.out.println(string + " ");
	}
}

    为Other.main()的参数而创建的数组是在方法调用处创建的,因此你甚至可以在调用时提供可替换的参数。

二、可变参数列表

    第二种形式提供了一种方便的语法来创建对象并调用方法,以获得与C的可变参数列表一样的效果。这可以应用于参数个数或类型未知的场合。由于所有的类都直接或间接继承于Object类,所以可以创建以Object数组为参数的方法,并像下面这样调用:

class A {
}

public class VarArgs {
	static void printArray(Object[] args) {
		for (Object object : args)
			System.out.print(object + " ");
		System.out.println();
	}

	public static void main(String[] args) {
		printArray(new Object[] { new Integer(47), new Float(3.14), new Double(11.11) });
		printArray(new Object[] { "one", "two", "three" });
		printArray(new Object[] { new A(), new A(), new A() });
	}
}

    可以看到print()方法使用Object数组作为参数,然后使用foreach语法遍历数组,打印每个对象。标准java库中的类能输出有意义的内容,但这里建立的类的对象,打印出的内容只是类的名称以及后面紧跟着一个@符号以及多个十六进制数字。于是,默认行为就是打印类的名称和对象的地址。

    在java SE5以后,你可以使用可变参数列表。例如:

public class NewVarArgs {
	static void printArray(Object... args) {
		for (Object object : args)
			System.out.print(object + " ");
		System.out.println();
	}

	public static void main(String[] args) {
		printArray(new Object[] { new Integer(47), new Float(3.14), new Double(11.11) });
		printArray(47, 3.14F, 11.11);
		printArray("one", "two", "three");
		printArray(new A(), new A(), new A());
		printArray((Object[]) new Integer[] { 1, 2, 3, 4 });
		printArray();
	}
}

    有了可变参数,就再也不用显示地编写数组语法了,当你指定参数时,编译器实际上会为你去填充数组。你获取的仍旧是一个数组,这就是为什么print()可以使用foreach来迭代该数组的原因。但是,这不仅仅只是从元素列表到数组的自动转换,请注意程序中倒数第二行,一个Integer数组(通过使用自动包装而创建的)被转型为一个Object数组(以便移除编译器警告信息),并且传递给了printArray()。很明显,编译器会发现他已经是一个数组了,所以不会在其上执行任何转换。因此,如果你有一组事物,可以把它们当作列表传递,而如果你已经有了一个数组,该方法可以把它们当作可变参数列表来接受。

    该程序的最后一行表明将0个参数传递给可变参数列表是可行的,当具有可选的尾随参数时,这一特性就会很有用:

public class OptionalTrailingArguments {
	static void f(int required, String... trailing) {
		System.out.print("required: " + required + " ");
		for (String string : trailing)
			System.out.print(string + " ");
		System.out.println();
	}

	public static void main(String[] args) {
		f(1, "one");
		f(2, "two", "three");
		f(0);
	}
}

    这个程序还展示了你可以如何使用具有Object之外类型的可变参数列表。这里所有的可变参数都必须是String对象。在可变参数列表中可以使用任何类型的对参数,包括基本类型。下面的例子也展示了可变参数列表变为数组的情形,并且如果在该列表中没有任何元素,那么转变成的数据尺寸为0:

public class VarargType {
	static void f(Character... args) {
		System.out.println(args.getClass());
		System.out.println(" length " + args.length);
	}

	static void g(int... args) {
		System.out.println(args.getClass());
		System.out.println(" length " + args.length);
	}

	public static void main(String[] args) {
		f('a');
		f();
		g(1);
		g();
		System.out.println("int[]: " + new int[0].getClass());
	}
}

    getClass()方法属于Object的一部分,它将产生对象的类,并且打印该类时,可以看到表示该类类型的编码字符串。前导的“[”表示这是一个后面紧随的类型的数组,而紧随的“I”表示基本类型int。为了进行双重检查,我在最后一行创建了一个int数组,并打印了其类型。这样也就验证了使用可变参数列表不依赖于自动包装机制,而实际上使用的是基本类型。

    然而,可变参数列表与自动包装机制可以和谐共处,例如:

public class AutoboxingVarargs {
	public static void f(Integer... args) {
		for (Integer integer : args)
			System.out.print(integer + " ");
		System.out.println();
	}

	public static void main(String[] args) {
		f(new Integer(1), new Integer(2));
		f(4, 5, 6, 7, 8, 9);
		f(10, new Integer(11), 12);
	}
}

    请注意,你可以在单一的参数列表中将类型混合在一起,而自动包装机制将有选择地将int参数提升为Integer。

    可变参数列表使得重载过程变得复杂了,尽管乍一看会显得足够安全:

public class OverloadingVarargs {
	static void f(Character... args) {
		System.out.print("first");
		for (Character character : args)
			System.out.print(" " + character);
		System.out.println();
	}

	static void f(Integer... args) {
		System.out.print("second");
		for (Integer integer : args)
			System.out.print(" " + integer);
		System.out.println();
	}

	static void f(Long... args) {
		System.out.println("third");
	}

	public static void main(String[] args) {
		f('a', 'b', 'c');
		f(1);
		f(2, 1);
		f(0);
		f(0L);
		// f();
	}
}

    在每一种情况中,编译器都会使用自动包装机制来匹配重载的方法,然后调用最明确的匹配的方法。

    但是在不使用参数调用f()时,编译器就无法知道应该调用哪一个方法了,尽管这个错误可以弄清楚,但是它可能会使客户端程序员大感意外。

    你可能会通过在某个方法中增加一个非可变参数来解决该问题:

public class OverloadingVarargs2 {
	static void f(float i, Character... args) {
		System.out.println("first");
	}

	static void f(Character... args) {
		System.out.println("second");
	}

	public static void main(String[] args) {
		f(1, 'a');
		//f('a', 'b');
	}
}

    如果你给这两个方法都添加一个非可变参数,就可以解决问题了:

public class OverloadingVarargs2 {
	static void f(float i, Character... args) {
		System.out.println("first");
	}

	static void f(char c, Character... args) {
		System.out.println("second");
	}

	public static void main(String[] args) {
		f(1, 'a');
		f('a', 'b');
	}
}

    你应该总是只在重载方法的一个版本上使用可变参数列表,或者压根就不用它。

发布了71 篇原创文章 · 获赞 2 · 访问量 7469

注意:本文归作者所有,未经作者允许,不得转载

全部评论: 0

    我有话说: