==== 数组 ==== 数组和容器 ---------- 在 Java 中，数组是一种 **效率最高** 的存储和随机访问对象引用序列的方式。 数组就是一个简单的线性序列，这使得元素访问非常迅速。 但是，为这种速度所付出的代价是数组对象的大小被固定，并且在其生命周期中不可改变。 在泛型之前，其他的容器类在处理对象时，都将它们视作没有任何具体类型，也就是说，它们将这些对象都当作 ``Object`` 来处理。 有了泛型之后，容器就可以指定并检查它们所持有对象的类型，并且有了自动包装机制，容器还能够持有基本类型。 容器和泛型对数组产生了极大的冲击，并且现在的容器在除了性能之外的各个方面都碾压数组。 通常，即使当你可以让泛型与数组以某种方式一起工作时，在编译器你最终也会得到 "不受检查" 的警告信息。 针对大多数场景，用的更多的是容器，而不是数组，除非你对性能有更高的要求。 数组初始化 ----------- 创建基本类型的 **一维数组**，很简单。如下所示： .. code-block:: java :emphasize-lines: 6-8 :linenos: //: initialization/ArraysOfPrimitives.java import static net.mindview.util.Print.*; public class ArraysOfPrimitives { 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] = a2[i] + 1; for(int i = 0; i < a1.length; i++) print("a1[" + i + "] = " + a1[i]); } } /* Output: a1[0] = 2 a1[1] = 3 a1[2] = 4 a1[3] = 5 a1[4] = 6 *///:~ 如果你创建的是 **非基本类型的数组**，那么你就创建了一个引用数组（存放引用的数组）。 如果数组中存储的是对象的引用，那么我们就称之为对象数组。 对象数组和基本类型数组在使用上几乎是相同的，唯一的区别就是对象数组保存的是对象的引用。 无论使用哪种类型的数组，数组标识符其实只是一个引用，表示堆中的一个真实对象的别名（\ **这部分有争议，需要修改**）。这个真实对象中保存了指向其他对象的引用。 C/C++ 无法返回整个数组，只能返回指向数组的指针，但这使数组的生命周期难以控制，容易内存泄漏。 而 Java 可以直接返回一个数组对象（也是一个引用），使用完成后垃圾回收器会自动清理。 .. code-block:: java :emphasize-lines: 9 :linenos: //: initialization/ArrayClassObj.java // Creating an array of nonprimitive objects. import java.util.*; import static net.mindview.util.Print.*; public class ArrayClassObj { public static void main(String[] args) { Random rand = new Random(47); Integer[] a = new Integer[rand.nextInt(20)]; // a 是一个引用 print("length of a = " + a.length); for(int i = 0; i < a.length; i++) a[i] = rand.nextInt(500); // 自动包装，指的是基本类型自动转为包装类 print(Arrays.toString(a)); } } /* Output: (Sample) length of a = 18 [55, 193, 361, 461, 429, 368, 200, 22, 207, 288, 128, 51, 89, 309, 278, 498, 361, 20] *///:~ 创建基本类型的 **多维数组**，可以使用花括号将每个向量分隔开（每个向量的维度可以不相等）。 .. code-block:: java //: arrays/AutoboxingArrays.java import java.util.*; public class AutoboxingArrays { public static void main(String[] args) { Integer[][] a = { // Autoboxing: { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, { 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 }, { 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 }, { 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 }, }; System.out.println(Arrays.deepToString(a)); } } /* Output: [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [21, 22, 23, 24, 25, 26, 27, 28, 29, 30], [51, 52, 53, 54, 55, 56, 57, 58, 59, 60], [71, 72, 73, 74, 75, 76, 77, 78, 79, 80]] *///:~ .. _variable-argument-list: 可变参数列表 ------------- 可变参数列表其实是一个数组，因此，可以用 ``foreach`` 来进行遍历，见如下代码。 .. code-block:: java :emphasize-lines: 5,6,19 :linenos: //: initialization/NewVarArgs.java // Using array syntax to create variable argument lists. public class NewVarArgs { // static void printArray(Object[] args) { // 老语法，main 函数就在使用 static void printArray(Object... args) { // 新语法 for(Object obj : args) System.out.print(obj + " "); System.out.println(); } public static void main(String[] args) { // Can take individual elements: printArray(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()); // Or an array: printArray((Object[])new Integer[]{ 1, 2, 3, 4 }); printArray(); // Empty list is OK } } /* Output: (75% match) 47 3.14 11.11 47 3.14 11.11 one two three A@1bab50a A@c3c749 A@150bd4d 1 2 3 4 *///:~ 除此之外，可变参数列表支持自动包装机制（自动包装指的是基本类型自动转为包装类）。 但是，可变参数列表使重载变得更复杂了。 如果给定 ``f()``，编译器不知道该调用 ``f(Character... args)`` 还是 ``f(Integer... args)``。 这个问题可以通过添加非可变参数来解决 ``f(float i, Character... args)``。 数组的判空方法 -------------- 一维数组： ``array.length == 0`` 二维数组： ``array.length == 0 || array[0].length == 0`` 数组复制和排序 -------------- 复制数组： ``System.arraycopy()``。 数组的比较： ``Arrays.equals()``。 数组元素的比较，有两种方式： 1. 实现 ``java.lang.Comparable`` 接口。 2. 自建 ``Comparator`` 接口，并提供 ``compare()`` 和 ``equals()`` 方法声明。 数组排序，分情况讨论： - 基本类型 ``Arrays.sort()`` 可以排序。 - 自定义类型需要实现 ``java.lang.Comparable`` 接口。 在已排序的数组中查找： ``Arrays.binarySearch()``。 数组与泛型 ---------- 通常，数组与泛型不能很好地结合，取而代之的是容器和泛型的结合。 如果你非要结合数组和泛型，也不是不可以，但不推荐使用，故本小节仅作为了解知识即可。 不能实例化具有参数化类型的数组。 因为编译器会进行 :ref:`erase-typeinfo`，而数组又必须知道它所持有的确切类型，以强制保证类型安全。 因此下述代码并不合法。 .. code-block:: java Peel[] peels = new Peel[10]; // Illegal 但是，你可以参数化数组本身的类型： .. code-block:: java //: arrays/ParameterizedArrayType.java class ClassParameter { public T[] f(T[] arg) { return arg; } } class MethodParameter { public static T[] f(T[] arg) { return arg; } } public class ParameterizedArrayType { public static void main(String[] args) { Integer[] ints = { 1, 2, 3, 4, 5 }; Double[] doubles = { 1.1, 2.2, 3.3, 4.4, 5.5 }; Integer[] ints2 = new ClassParameter().f(ints); // 参数化类须人为指定参数类型 Double[] doubles2 = new ClassParameter().f(doubles); ints2 = MethodParameter.f(ints); // 参数化方法会自动识别实参类型 doubles2 = MethodParameter.f(doubles); } } ///:~ 阅读上述代码可知，使用参数化方法比使用参数化类更加方便。 由于擦除的存在，我们将不能创建泛型数组。因为移除类型信息后，不能创建类型未知的数组。 但是，你可以创建 ``Object`` 数组，然后将其转型。 .. code-block:: java //: arrays/ArrayOfGenericType.java // Arrays of generic types won't compile. public class ArrayOfGenericType { T[] array; // OK @SuppressWarnings("unchecked") public ArrayOfGenericType(int size) { //! array = new T[size]; // Illegal, unknown type array = (T[])new Object[size]; // "unchecked" Warning } // Illegal: //! public U[] makeArray() { return new U[10]; } } ///:~ 一般而言，泛型在类或方法的边界处很有效，而在类或方法的内部，擦除通常会使泛型变得不适用。