操纵Java数组

如果你做过很多java程序，你可能对java集合类很熟悉，例如Vector和ArrayList。你可以创建一个集合并向其中增加元素：

1.     List lst = new ArrayList();
2.     lst.add(new Integer(37));

在这个特殊的范例中，一个整型值37用于构造一个Integer封装类对象，然后那个对象被加入到列表。

这个简单的范例展示集合的一个基础－他们用于操纵一列对象，其中的每个对象是一个类或者接口类型。因此，一个ArrayList可以包含Object,String,Float以及Runnable类型的对象。集合类不能用于原始数据类型的列表，例如整型数组。

如果你在你的程序中使用原始类型的数组，你如何操纵它们呢？这个技巧就给你展示几个你可以使用的技术。

第一个技术是排序。java.util.Arrays类包含一套排序和查找数组的类方法，例如：

1.     import java.util.Arrays;
2.     public class ArrayDemo1 {
3.         public static void main(String args[]) {
4.             int vec[] = {37, 47, 23, -5, 19, 56};
5.             Arrays.sort(vec);
6.             for (int i = 0; i < vec.length; i++) {
7.                 System.out.println(vec[i]);
8.             }
9.         }
10.     }

这个演示程序初始化一个整数数组然后调用Arrays.sort升序排序那个数组。

类似的，你可以在排完序的数组上进行二分法查找：

1.     import java.util.Arrays;
2.     public class ArrayDemo2 {
3.         public static void main(String args[]) {
4.             int vec[] = {-5, 19, 23, 37, 47, 56};
5.             int slot = Arrays.binarySearch(vec, 35);
6.             slot = -(slot + 1);
7.             System.out.println("insertion point = " + slot);
8.         }
9.     }

这个程序有个微妙的概念，如果二分法查找失败它将返回：

    -(insertion point) - 1

这个演示程序以参数35调用查找方法，而那个参数在数组中不存在，方法返回值－4，如果这个值加一再取其负数就得到3，这就是35应该被插入到数组中的位置，换言之，值-5, 19和23在数组中占据的位置是0，1和2。因此值35应该在索引3的位置，而37, 47以及56顺延。搜索方法并不进行实际的插入操作而只是指出应该在何处插入。

除了排序和查找，我们还可以对原始类型数组做什么？另一个有用的技术是将一个原始数组转换为等价的对象类型数组。每个对应元素使用它们的封装器类，例如在封装数组中，37成为Integer(37)。

1.     import java.util.Arrays;
2.     import java.lang.reflect.Array;
3.     
4.     public class ArrayDemo3 {
5.     
6.         // if input is a single-dimension primitive array,
7.         // return a new array consisting of wrapped elements,
8.         // else just return input argument
9.     
10.         public static Object toArray(Object vec) {
11.     
12.             // if null, return
13.     
14.             if (vec == null) {
15.                 return vec;
16.             }
17.     
18.             // if not an array or elements not primitive, return
19.     
20.             Class cls = vec.getClass();
21.             if (!cls.isArray()) {
22.                 return vec;
23.             }
24.             if (!cls.getComponentType().isPrimitive()) {
25.                 return vec;
26.             }
27.     
28.             // get array length and create Object output array
29.     
30.             int length = Array.getLength(vec);
31.             Object newvec[] = new Object[length];
32.     
33.             // wrap and copy elements
34.     
35.             for (int i = 0; i < length; i++) {
36.                 newvec[i] = Array.get(vec, i);
37.             }
38.     
39.             return newvec;
40.         }
41.     
42.         public static void main(String args[]) {
43.     
44.             // create a primitive array
45.     
46.             int vec[] = new int[]{1, 2, 3};
47.     
48.             // wrap it
49.     
50.             Object wrappedvec[] = (Object[])toArray(vec);
51.     
52.             // display result
53.     
54.             for (int i = 0; i < wrappedvec.length; i++) {
55.                 System.out.println(wrappedvec[i]);
56.             }
57.         }
58.     }

方法"toArray"的参数是一个Object对象(数组可以被赋值给一个Object引用)。如果参数是null或者代表的不是原始类型数组那么这个方法简单的返回参数值。java.lang.Class工具类用于判断参数是否是一个数组并获取数组的底层元素的类型。

一旦做完这些检查，使用java.lang.reflect.Array工具类的反射工具方法就可以获取原始数组的长度并获得数组的单个元素。Array.get获得的每个元素被返回到封装器类中，例如Integer或者Double。

最终的范例基于前面的那个并向你展示如何在数组上使用集合特性。这假设你已经有一个对象数组。

1.     import java.util.Arrays;
2.     import java.util.List;
3.     public class ArrayDemo4 {
4.         public static void main(String args[]) {
5.             Object vec[] = {new Integer(37), new Integer(47)};
6.             List lst = Arrays.asList(vec);
7.             lst.set(1, new Integer(57));
8.             for (int i = 0; i < vec.length; i++) {
9.                 System.out.println(vec[i]);
10.             }
11.         }
12.     }

在这个程序中，vec是一个对象数组，包含Integer(37)和Integer(47)，然后 Arrays.asList被调用。它返回一个集合(List接口类型)，使用数组作为集合的后台存储。换言之，ArrayList这样的集合类型在它内部有某种存储类型去存储集合元素。在这个例子中，使用的存储类型是作为参数传递到Arrays.asList的数组。这意味着集合方法所做的改变会被反射到底层的数组。

修改集合中的元素1导致底层的数组也改变，程序的输出是：

    37
    57

因此如果你有一个对象数组，你可以在它上面使用集合特性，数组自身作为底层存储。

我们也可以将集合转换为一个对象数组，例如：

    Object vec[] = lst.toArray();