Java中的System、Arrays类

System类：位于Java.lang包中，表示当前Java程序运行平台。

        System类中的构造方法是private，所以无法通过new实例化对象，无法得到该类的对象。

        系统级的属性和控制方法都在该类的内部。

System中的静态成员变量：

        PrintStream Out：标准输出流，接收准备输出的数据

                方法：System.our.println()

        InputStream In:标准输入流，准备提供输入数据

                方法：System.in()

        PrintStream err：标准错误输出流，输出错误信息。

System类中的方法：

        exit：退出当前程序 （0表示一个状态）

System.exit(0);

        arraycopy：复制数组元素

/** arraycopy方法中参数说明：
    * Object src：源数组
    * int  srcPos：从源数组的哪个位置开始拷贝
    * Object dest：目标数组
    * int destPos：拷贝到目标数组的哪个位置
    * int length：拷贝多少个元素
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length)

 */
int[] src = { 1, 2, 3, 4, 5 };
int[] desc = new int[4]; // 初始时，desc数组中存放的是[0, 0, 0, 0]
System.arraycopy(src, 1, desc, 1, 3);
System.out.println(desc); // [0, 2, 3, 4]

        currentTimeMillis()：返回当前计算机时间，格式是当前时间距离1970年1月1日 0时0分0秒的毫秒差。

                一般使用该方法，测量程序的执行时间。

long start = System.currentTimeMillis();
for (int i = 1; i <= 1000000; i++) {
    int temp = 0;
}
long end = System.currentTimeMillis();
long time = end - start; // 时间差
System.out.println(time); // for循环这段程序的执行时间

        gc()：垃圾回收机制。

                请求系统进行垃圾回收，完成内存垃圾清理。（根据系统中垃圾回收算法及系统执行情况决定是否立即进行回收）

System.gc();

Arrays：工具类，用于管理和操作数组

        Arrays类中的方法通过static修饰，都是静态方法，因此可以通过类名直接调用：Arrays.xxx.

        toString()：返回数组的字符串表示

int[] arr = { 0, 1, 2, 3 };
System.out.println(Arrays.toString(arr)); // [0, 1, 2, 3]

        binarySearch()：二叉树搜索法查找数组元素

                使用binarySearch方法查找元素，要求数组必须是有序的（从小到大、从大到小）

                binarySearch()方法实现了重载。

                        int binarySearch(type[] array, type key)：在array数组中查找key，返回索引

                        int binarySearch(type[] array, int fromIndex, int toIndex, type key)：在array数组fromIndex到toIndex的位置查找key，返回索引

                        如果数组中不存在key，返回  -（a应该在的位置+1）

int[] arr = { 1, 12, 23, 34, 45, 56, 67, 78, 89, 90 };

System.out.println(Arrays.binarySearch(arr, 23)); // 2

System.out.println(Arrays.binarySearch(arr, 25)); // -4

        copeOf()：拷贝数组元素

                type[] copeOf(type[] original, int length)：从original数组中拷贝length个元素到新数组

                        如果length<0，则系统抛出异常；

                        如果length>original.length，则使用null填充剩下的空间

int[] arr = { 11, 22, 33, 44, 55 };

int[] arr1 = Arrays.copeOf(arr, 5);
System.out.println(arr1); // [11, 22, 33, 44, 55]

int[] arr2 = Arrays.copeOf(arr, 7);
System.out.println(arr2); // [11, 22, 33, 44, 55, null, null]

        fill()：数组填充

                fill(type[] arr, type value)：使用value填充到数组arr中

int[] arr = { 0, 1 , 2 };

Arrays.fill(arr, 99);
System.out.println(arr); // [99, 99, 99]

        equals()：比较数组是否相等

int[] arr = {-1, 8, 25, 16};

int[] arr1 = {-1, 8, 25, 16};
boolean equals1 = Arrays.equals(arr, arr1);
System.out.println(equals1); // true

int[] arr2 = {-1, 8, 25, 16, 0};
boolean equals2 = Arrays.equals(arr, arr2);
System.out.println(equals2); // false

        alist()：将数组转化为list集合

List asList = Arrays.alist(1, 2, 3, 4);

System.out.println(asList); // [1, 2, 3, 4]
System.out.println("asList的运行类型" + asList.getClass()); // java.util.Arrays$ArrayList

        sort()：对数组内容进行排序

                sort(type[] arr)、sort(type[] arr, int fromIndex, int toIndex)：自然排序（从大到小）

        利用sort方法实现定制排序：public static <T> void sort(T[] a, Comparator<? super T> c）

                方法中第一个参数：需要进行排序的数组；第二个参数：匿名内部类

String[] arr = {"kxg", "kxy", "kxh", "kfb", "lhy"};

// 对arr进行排序
Arrays.sort(arr, new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        String str1 = (String)o1;
        String str2 = (String)o2;
        return str1.compareTo(str2);
    }
});
for (String str:array) {
    System.out.println(str);
}

                sort方法可以对所有数组按照一定顺序进行比较。