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)
    }
}