1.最普通的拷贝

对于拷贝，大家都能理解和知道的肯定就是自己写一个方法去实现拷贝，也就是在main方法中调用一个方法，返回一个数组是拷贝完成的数组。

代码实现：

public static int[] copyArray(int [] array){
        int [] copy = new int[array.length];//创建一个新的数组
        
        for(int i = 0;i<array.length;i++){
            copy[i]=array[i];
        }//遍历拷贝
        return copy;
    }


    public static void main(String[] args) {

        int [] array = {1,2,3,4,5,6};
        int [] ret = copyArray(array);//接收拷贝返回数组
        System.out.println(Arrays.toString(ret));//打印数组

    }

2.Arrays.copyof()

第二种就是Arrays.copyof（）方法了，这是Java中Arrays类中提供的copyOf方法，用起来也是十分方便的。

在这里插入图片描述

代码实现：

public static void main(String[] args) {

        int [] array = {1,2,3,4,5,6};
        int []ret = Arrays.copyOf(array,array.length);
        //Arrays.copyOf方法调用
        System.out.println(Arrays.toString(ret));
        //打印结果：[1,2,3,4,5,6]
    }

对于这个方法，我们传参的长度也可以设置自己想要的长度，如果大于拷贝数组的长度，拷贝得到的数组会相当于自动扩容，得到后面初始值为0的元素。

比如：

public static void main(String[] args) {

        int [] array = {1,2,3,4,5,6};
        int []ret = Arrays.copyOf(array,array.length*2);
        //Arrays.copyOf方法调用
        System.out.println(Arrays.toString(ret));
        //打印结果：[1,2,3,4,5,6,0,0,0,0,0]
    }

同时我们可以在IDEA中按住ctrl键点击copyOf查看其源码，这里看见长度是int类型的，说明如果你想要扩容是不能扩容小数倍数的：

//源码
public static int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

然后对于copyOf这个函数，在其源码中又调用了System.arraycopy这个函数，所以接下来我们又可以看一下这个方法的拷贝，但在这之前，我们先看另一个拷贝函数，它就是。

3.copyOfRange()

对于copyOfRange()函数，它其实是一个可以拷贝一部分的一个拷贝函数，参数是拷贝的函数，form to是下标范围。

在这里插入图片描述

代码实现：

public static void main(String[] args) {

        int [] array = {1,2,3,4,5,6};
        int []ret = Arrays.copyOfRange(array,1,3);

        System.out.println(Arrays.toString(ret));
        //打印结果:[2,3]
    }

这里需要注意一个点，就是对于在Java中输入参数是from…to…的，他的取值都是左闭右开的，也就是左值会去，但右值是不取的，比如这里是1，3，但是拷贝的只是下标为1，2的两个元素。

我们也可以在其源码中看出：

//源码
public static int[] copyOfRange(int[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        int[] copy = new int[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

4.System.arraycopy()

然后就是我们上面看见的这个函数了，我们可以看一下它的参数：

在这里插入图片描述
总共有5个参数，从头到尾是源数组，从源数组的某一个位置开始拷贝，拷贝到某一个数组，拷贝到某一个数组的某一个位置，拷贝长度。

代码实现：

public static void main(String[] args) {

        int [] array = {1,2,3,4,5,6};
        int []copy = new int[array.length];
        System.arraycopy(array,0,copy,0,array.length);
        System.out.println(Arrays.toString(copy));

    }

但是对于copyOfRange()和System.arraycopy()，他们的长度是有范围的，不能超出他们的范围。

同样的我们可以去看看他的源码：

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

这里就出现一个奇怪的现象了，这里没有实现呀，就只有这些参数，同时这里还多了一个native，其实这里表示的是这段代码是被C/C++实现了的，他的特点是速度快，所以这是一个native方法。

5.克隆clone

代码实现：

public static void main(String[] args) {

        int [] array = {1,2,3,4,5,6};
        int []copy = array.clone();

        System.out.println(Arrays.toString(copy));

    }