使用System.arraycopy()容易忽略的问题

最新推荐文章于 2022-08-25 15:15:21 发布

转载最新推荐文章于 2022-08-25 15:15:21 发布 · 307 阅读

1 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/weikongziqu/p/5808184.html

文章标签：

#java

本文详细介绍了Java中的arraycopy()方法，包括其参数说明、常见使用方法及潜在问题。特别是关于浅复制导致的数据引用问题，通过实例展示了如何影响数组数据一致性。

arraycopy()方法在JDK中是这样介绍的：

void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

Copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array.

A subsequence of array components are copied from the source array referenced by src to the destination array referenced by dest.

The number of components copied is equal to the length argument. The components at positions srcPos through srcPos+length-1 in

the source array are copied into positions destPos through destPos+length-1, respectively, of the destination array.

If the src and dest arguments refer to the same array object, then the copying is performed as if the components

at positions srcPos through srcPos+length-1 were first copied to a temporary array with length components

and then the contents of the temporary array were copied into positions destPos through destPos+length-1 of the destination array.

下面简单介绍一下:

参数：

src:源数组；	srcPos:源数组要复制的起始位置；

dest:目的数组；	destPos:目的数组放置的起始位置；	length:复制的长度。

简单描述就是从src的srcPos位置拷贝length长度的数据到dest的destPos位置，如果src和dest是同一个对象的话，则相当于先将数据拷贝到一个临时的数组，然后再覆盖数组中destPos开始的一段数据。

常见的使用方法:

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

但是，使用此方法有个很严重的问题，由于它的复制是浅复制（shallow copy），复制后的数组与原数组中的数据指向同一个位置.

示例如下:

public class Clone2 {
    public static void main(String[] args) {
        Te[] t1 = new Te[1];
        t1[0] = new Te("a");
        Te[] t2 = new Te[1];
        System.out.println(t1[0]);
        //调用
        System.arraycopy(t1, 0, t2, 0, 1);
        System.out.println(t2[0]);
    }
}
class Te{
    String name;
    Te(String name) {
        this.name = name;
    }
}
//输出
/*
CloneTest.Te@74a14482
CloneTest.Te@74a14482
*/

从上面的输出可以看出复制后的数组中的元素与原来指向了一个位置，这样子很容易引发严重的问题.一旦我们更改了原来的数据,复制后的数据也会随之改变.

例如:

public class Clone2 {
    public static void main(String[] args) {
        Te[] t1 = new Te[1];
        t1[0] = new Te("a");
        Te[] t2 = new Te[1];
        System.out.println("t1修改前："+t1[0]);
        //修改t1[0]
        t1[0].name = "2";
        System.out.println("t1修改后："+t1[0]);
        //调用
        System.arraycopy(t1, 0, t2, 0, 1);
        System.out.println("t2："+t2[0]);
    }
}
class Te{
    String name;
    Te(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Te{" +
                "name='" + name + '\'' +
                '}';
    }
}
//输出：
/*
t1修改前：Te{name='a'}
t1修改后：Te{name='2'}
t2：Te{name='2'}
 */