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)

     }

 }

巴特西

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

最新文章

热门文章