数组拷贝

首先了解深拷贝浅拷贝
数组的四种拷贝方式：

1.for循环拷贝

代码示例：

import java.util.Arrays;

public class TestDemo{

    public static void main(String[] args) {

        int[] array1 ={1,2,3,4,5,6};

        int[] array2 =new int [array1.length];

        for (int i = 0; i <array1.length ; i++) {

            array2[i] = array1[i];

        }

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

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

    }

}

结果：

此时，修改array2 0下标的值，发现对array1没影响；

import java.util.Arrays;

public class TestDemo{

    public static void main(String[] args) {

        int[] array1 ={1,2,3,4,5,6};

        int[] array2 =new int [array1.length];

        for (int i = 0; i <array1.length ; i++) {

            array2[i] = array1[i];

        }

        System.out.println("==============");

        array2[0]=99;

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

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

    }

}

结果：

创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中. 因此, 修改原数组, 不会影响到新数组，即通过一个引用去修改拷贝后的值，发现并不影响原来对象的值，这种拷贝属于深拷贝。

2.copyof拷贝

代码示例：

public static void main(String[] args) {

        int[] array1 = {1,2,3,4,5,6};

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

        int[] array2 = Arrays.copyOf(array1,array1.length);

        System.out.println("==============");

        array2[0]=99;

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

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

    }

结果：

同第一个： copyOf 是将数组进行了深拷贝, 即又创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中。因此, 修改原数组,不会影响到新数组。

3.System.arraycopy拷贝

import java.util.Arrays;

public class TestDemo {

    public static void main(String[] args) {

        int[] array1 = {1, 2, 3, 4, 5, 6};

        int[] array2 = new int[array1.length];

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

        System.arraycopy(array1, 0, array2, 0, array1.length);

        System.out.println("==============");

        array2[0] = 99;

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

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

    }

}

结果：

System.arraycopy拷贝也为深拷贝。

前三种拷贝方式速度最快是System.arraycopy拷贝。

4.clone拷贝

   引用.clone

         克隆  这个引用所指向的对象

         这个引用所指向的对象就会被克隆(生成一个副本)

代码示例;

public static void main(String[] args) {

        int[] array1 = {1, 8, 9, 4, 13, 26};

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

        //array2 指向了刚刚生成的副本

        int [] array2 = array1.clone();

        System.out.println("==============");

        array2[0] = 99;

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

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

    }

结果：

此时也可以看出，修改原数组, 不会影响到新数组。所以也为深拷贝。
实际上，本质来说这四种都属于浅拷贝
上面四种属于深拷贝的原因是因为刚刚数组中存放的是简单类型。
如果放的是引用类型，它们均属于浅拷贝。
画图说明浅拷贝：

当数组中存放的是引用类型时，修改array2中的某个元素的值，同时也修改了array1中的值，这种方法叫浅拷贝。
怎么修改成深拷贝呢？当我们拷贝array1时，将它所引用的值也拷贝过来，此时修改array2中的某个元素的值，array1中的值不变，如图：

总结：

这四种数组拷贝的方式均为浅拷贝

几个小知识点：

1.拷贝部分数组;

代码示例：

public static void main(String[] args) {

        int[] array1 = {2, 8, 9, 10, 12, 26};

        int[] ret = Arrays.copyOfRange(array1,2,5);

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

    }

结果：

2.比较两个数组

代码示例：

public static void main(String[] args) {

        int[] array1 = {2, 8, 9, 10, 12, 26};

        int[] array2 = {2, 8, 9, 10, 12, 26, 30,35};

        System.out.println(Arrays.equals(array1, array2));

    }

结果：

3.数组完全填充

代码示例：

public static void main(String[] args) {

        int[] array1 =new int[10];

        Arrays.fill(array1,6);

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

    }

结果：

4.数组部分填充

代码示例：

public static void main(String[] args) {

        int[] array1 =new int[10];

        Arrays.fill(array1,2,6,8);

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

    }

结果：

完。（要我的命）

原文章：https://blog.csdn.net/weixin_44436675/article/details/112012315

巴特西

Java-数组拷贝

数组拷贝

1.for循环拷贝

2.copyof拷贝

3.System.arraycopy拷贝

前三种拷贝方式速度最快是System.arraycopy拷贝。

4.clone拷贝

总结：

几个小知识点：

1.拷贝部分数组;

2.比较两个数组

3.数组完全填充

4.数组部分填充

最新文章

热门文章