Java数组(4)：数组实用功能

Java标准类库的System.arraycopy()方法，及在java.utils.Arrays类中一套用于数组的static方法，都是操纵数组实用功能。下面分别介绍。

(1) 数组的复制

(2) 数组的比较

(3) 数组的排序和查找

(1) 数组的复制

System.arraycopy(源数组, 从源数组的什么位置开始复制的偏移量, 目标数组, 从标数数组的什么位置开始复制的偏移量, 需要复制的元素的个数)

System.arraycopy已经对所有基本类型(包装类型同样适用)做了重载，如果复制对象，则只是浅复制(复制引用)。

下面以int作为示例：

 import java.util.Arrays;

 public class Test1 {
     public static void main(String[] args) {
         int[] i = new int[3];
         int[] j = new int[7];
         Arrays.fill(i, 47);
         Arrays.fill(j, 99);
         System.out.println("i = " + Arrays.toString(i)); // i = [47, 47, 47]
         System.out.println("j = " + Arrays.toString(j)); // j = [99, 99, 99, 99, 99, 99, 99]
         int[] k = new int[5];
         Arrays.fill(k, 103);
         System.arraycopy(i, 0, k, 0, i.length);
         System.out.println("k = " + Arrays.toString(k)); // k = [47, 47, 47, 103, 103]
         System.arraycopy(k, 1, j, 0, 4); //
         System.out.println("j = " + Arrays.toString(j)); // j = [47, 47, 103, 103, 99, 99, 99]
     }
 }

(2) 数组的比较

同样，Arrays.equals已经对所有基本类型(包装类型同样适用)做了重载，对于对象比较，使用了对象的equals方法，所以必须重写对象的equals方法。

 import java.util.Arrays;

 public class Test2 {
     public static void main(String[] args) {
         int[] a1 = new int[5];
         int[] a2 = new int[5];
         Arrays.fill(a1, 47);
         Arrays.fill(a2, 47);
         System.out.println(Arrays.equals(a1, a2)); // true
         a2[3] = 11;
         System.out.println(Arrays.equals(a1, a2)); // false
         String[] s1 = new String[4];
         Arrays.fill(s1, "Hi");
         String[] s2 = { "Hi", "Hi", new String("Hi"), new String("Hi") };
         System.out.println(Arrays.equals(s1, s2)); // true
     }
 }

(3) 数组的排序和查找

同样，Arrays.sort已经对所有基本类型(包装类型同样适用)做了重载，对于对象比较，必须实现Comparable接口。

如果数组已经排好序，就可以使用Arrays.binarySearch执行快速查找(前提必须是排好序的数组)。

如果使用了Comparator<T>排序了某个对象数组，使用Arrays.binarySearch时必须提供同样的Comparator<T>。

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

 class CompType implements Comparable<CompType> {
     int i;
     int j;

     public CompType(int n1, int n2) {
         i = n1;
         j = n2;
     }

     @Override
     public String toString() {
         return "(" + i + ", " + j + ")";
     }

     @Override
     public int compareTo(CompType ct) {
         return i == ct.i ? Integer.compare(j, ct.j) : Integer.compare(i, ct.i);
     }
 }

 public class Test3 {
     public static void main(String[] args) {

         // 基本类型
         Random random = new Random(47);
         int[] a = random.ints(5, 5, 10).toArray();
         System.out.println(Arrays.toString(a)); // [8, 5, 8, 6, 6]
         Arrays.sort(a); // Arrays.sort(基本类型)
         System.out.println(Arrays.toString(a)); // [5, 6, 6, 8, 8]

         // 包装类型
         Integer[] b = { 3, 5, 9, 8, 2 };
         Arrays.sort(b); // Arrays.sort(Object)
         System.out.println(Arrays.toString(b)); // [2, 3, 5, 8, 9]
         Arrays.sort(b, Collections.reverseOrder()); // Arrays.sort(Object, Comparator<T>)
         System.out.println(Arrays.toString(b)); // [9, 8, 5, 3, 2]

         // String
         String[] c = { "A", "B", "AB", "AC", "a", "b", "ab", "ac" };
         Arrays.sort(c); // 字符串默认是字典排序[A-Za-z]
         System.out.println(Arrays.toString(c)); // [A, AB, AC, B, a, ab, ac, b]
         Arrays.sort(c, String.CASE_INSENSITIVE_ORDER); // 忽略大小写排序
         System.out.println(Arrays.toString(c)); // [A, a, AB, ab, AC, ac, B, b]

         // 对象类型
         CompType[] d = { new CompType(2, 2), new CompType(1, 2), new CompType(2, 4), new CompType(0, 3),
                 new CompType(3, 4), new CompType(3, 0), new CompType(2, 2), new CompType(2, 1) };
         Arrays.sort(d);
         System.out.println(Arrays.toString(d)); // [(0, 3), (1, 2), (2, 1), (2, 2), (2, 2), (2, 4), (3, 0), (3, 4)]
         Arrays.sort(d, Collections.reverseOrder());
         System.out.println(Arrays.toString(d)); // [(3, 4), (3, 0), (2, 4), (2, 2), (2, 2), (2, 1), (1, 2), (0, 3)]

         // 快速查找
         Arrays.sort(b);
         int location = Arrays.binarySearch(b, 8);
         System.out.println("Location of [5] is " + location + ", b[" + location + "] = " + b[location]); // Location of [5] is 3, b[3] = 8

         Arrays.sort(c);
         location = Arrays.binarySearch(c, "AC");
         System.out.println("Location of [AC] is " + location + ", c[" + location + "] = " + c[location]); // Location of [AC] is 2, c[2] = AC

         Arrays.sort(c, String.CASE_INSENSITIVE_ORDER);
         location = Arrays.binarySearch(c, "AC", String.CASE_INSENSITIVE_ORDER);
         System.out.println("Location of [AC] is " + location + ", c[" + location + "] = " + c[location]); // Location of [AC] is 5, c[5] = ac

         Arrays.sort(d);
         location = Arrays.binarySearch(d, new CompType(2, 4));
         System.out.println("Location of (2, 4) is " + location + ", d[" + location + "] = " + d[location]); // Location of (2, 4) is 5, d[5] = (2, 4)
     }
 }