Java 数组中System.arraycopy()方法和System类中相关的其他方法的使用详解

博主前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住也分享一下给大家，
👉点击跳转到网站

方法介绍：

从指定的源数组中复制一个数组，从指定位置开始，到目标数组的指定位置。

 @FastNative
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

这个方法的五个参数，具体所表示的含义如下：

1. src：源数组，就是要复制的数组。
2. srcPos：源数组中的起始位置，就是要复制数组中具体的片段，全部复制自然是从零开始
3. dest：目标数组，要把源数组具体复制到哪个数组中。
4. destPos：目标数据中的起始位置，把源数组复制到目标数据中的位置。
5. length：要复制的数组元素的数量，如果全部要复制就是源数组arr.length

合并数组就用到了这个方法，大家可以体会一下：

	//合并数组
    public static byte[] byteMerger(byte[] bt1, byte[] bt2) {
        byte[] bt3 = new byte[bt1.length + bt2.length];
        System.arraycopy(bt1, 0, bt3, 0, bt1.length);
        System.arraycopy(bt2, 0, bt3, bt1.length, bt2.length);
        return bt3;
    }

具体实例，加深理解

public static void main(String[] args) {
 		int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {5, 6, 7, 8, 9};
        //把array2数组复制到array1中
        System.arraycopy(array2, 0, array1, 1, 4);
        System.out.println(Arrays.toString(array1));
}

输出结果：

System类中其他的常见方法如下

public class System_ {
    public static void main(String[] args) {
        //exit 退出当前程序
//        System.out.println("ok1");
//        //1.exit(0) 表示程序退出
//        //2.0表示一个状态，正常的状态
//        System.exit(0);
//        System.out.println("ok2");


        int[] src = {1, 2, 3};
        int[] dest = new int[3];
        //1.主要搞清楚这五个参数的含义
        //  src：源数组
        //  * @param      src      the source array.
        //      srcPos:从源数组的哪个索引位置开始拷贝
        //     * @param      srcPos   starting position in the source array.
        //    dest:目标数组，即把源数组的数据拷贝到哪个数组
        //     * @param      dest     the destination array.
        //    destPos:把源数组的数据拷贝到 目标数组的哪个索引
        //     * @param      destPos  starting position in the destination data.
        //  length:从源数组拷贝多少个数据到目标数组
        //     * @param      length   the number of array elements to be copied.
//        System.arraycopy(src, 0, dest, 0, 3); //对应输出的结果为：[1,2,3]
//        System.arraycopy(src, 0, dest, 1, 2); //对应输出的结果为：[0,1,2]
//        System.arraycopy(src, 1, dest, 1, 2); //对应输出的结果为：[0,2,3]
//        System.arraycopy(src, 0, dest, 0, src.length - 1); //对应输出的结果为：[1,2,0]
        System.arraycopy(src, 1, dest, 1, src.length - 1);
        System.out.println(Arrays.toString(dest));


        //currentTimeMillis :返回当前时间距离1970-1-1的毫秒数
        System.out.println(System.currentTimeMillis());
    }
}

输出结果

[0, 2, 3]
1651201130840

System.gc方法和finalize方法的配合使用如下

测试的代码如下

public class Finalize_ {
    public static void main(String[] args) {
        Car bmw = new Car("宝马");
        //这时 car对象就是一个垃圾，垃圾回收器就会回收(销毁)对象，在销毁对象前，会调用该对象的finalize()方法
        //程序员就可以在finalize中，写自己的业务逻辑代码(比如释放资源，数据库连接，或者打开文件..)
        //如果程序员不重写finalize，那么就会调用Object类的finalize，即默认处理
        //如果程序员重写了finalize，就可以实现自己的逻辑
        bmw = null;
        System.gc();//主动调用垃圾回收器
        System.out.println("程序退出...");
    }
}

class Car {
    private String name;

    public Car(String name) {
        this.name = name;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("我们销毁 汽车" + name);
        System.out.println("释放了某些资源");
    }
}

输出结果如下

我们销毁 汽车宝马
释放了某些资源
程序退出...

有不当之处，可以在评论区指出，共同进步~