System.arraycopy()方法使用
定义
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
可以看到,它是一个静态本地方法,由虚拟机实现,效率自然比用java一个个复制高。
方法含义
从源数组src取元素,范围为下标srcPos到srcPos+length-1,取出共length个元素,存放到目标数组中,存放位置为下标destPos到destPos+length-1。
简单说,就是数组间的复制
应用
常用作数组的扩容,如ArrayList底层数组的扩容
参数
- Object src:the source array. 源数组
- int srcPos:starting position in the source array. 在源数组中,开始复制的位置
- Object dest:the destination array. 目标数组
- int destPos:starting position in the destination data. 在目标数组中,开始赋值的位置
- int length:the number of array elements to be copied. 被复制的数组元素的数量
过程详解
以下面这个例子进行分析
public class SystemArrayCopy {
public static void main(String[] args) {
int[] src = {1, 2, 3, 4};
int[] dest = new int[5];
System.arraycopy(src, 0, dest, 1, 4);
for (Object o : dest) {
System.out.println(o);
}
}
}
/*
0 1 2 3 4
*/
src = |1|2|3|4|
dest = |0|0|0|0|0|
执行System.arraycopy(src, 0, dest, 1, 4);时
第一步:从源数组(src)中,从下标0开始取,取4个,也就是src[0]-src[3],即1 2 3 4四个数
第二步:把取出的数,按顺序,存放到目标数组(dest)中,从下标1开始存,存4个,也就是dest[1]-dest[4]
所以数组dest为:|0|1|2|3|4|
再来一个例子
public class SystemArrayCopy {
public static void main(String[] args) {
String[] src = {"aa", "bb", "cc", "cc"};
String[] dest = new String[]{"a", "b", "c", "d", "e"};
System.arraycopy(src, 1, dest, 2, 2);
for (Object o : dest) {
System.out.println(o);
}
}
}
/*
a b bb cc e
*/
String[] src = |"aa"|"bb"|"cc"|"cc"|
String[] dest = |"a"|"b"|"c"|"d"|"e"|
执行 System.arraycopy(src, 1, dest, 2, 2);时
第一步:从源数组(src)中,从下标1开始取,取2个,也就是src[1]-src[2],即"bb" "cc"两个字符串
第二步:把取出的数,按顺序,存放到目标数组(dest)中,从下标2开始存,存2个,也就是dest[2]-dest[3]
所以数组dest为:|"a"|"b"|"bb"|"cc"|"e"|
注意,目标数组下标范围外的元素不会改变!
深复制与浅复制
- 当数组为一维数组,且元素为基本类型或String类型时,属于深复制,即原数组与新数组的元素不会相互影响
- 当数组为多维数组,或一维数组中的元素为引用类型时,属于浅复制,原数组与新数组的元素引用指向同一个对象
- 这里说的影响,是两个数组复制后对应的元素,并不一定是下标对应
- String的特殊是因为它的不可变性
1. 一维数组,元素为基本类型
public class SystemArrayCopy {
public static void main(String[] args) {
String str1 = "aa";
String str2 = "bb";
String str3 = "cc";
String str4 = "dd";
String[] src = {str1, str2, str3, str4};
String[] dest = new String[4];
System.arraycopy(src, 0, dest, 0, 4);
System.out.println("改变前");
print("src = ", src);
print("dest = ", dest);
src[0] = "abcd";
System.out.println("改变后");
print("src = ", src);
print("dest = ", dest);
}
private static void print(String string, String[] arr) {
System.out.print(string);
for (String str : arr) {
System.out.print(str + " ");
}
System.out.println();
}
}
/*
改变前
src = aa bb cc dd
dest = aa bb cc dd
改变后
src = abcd bb cc dd
dest = aa bb cc dd
*/
可以看到,源数组第0个元素改变,并不会影响到目标数组
2. 多维数组
public class SystemArrayCopy {
public static void main(String[] args) {
int[] arr1 = {1, 2};
int[] arr2 = {3, 4};
int[] arr3 = {5, 6};
int[] arr4 = {7, 8};
int[][] src = new int[][]{arr1, arr2, arr3, arr4};
int[][] dest = new int[4][];
System.arraycopy(src, 0, dest, 0, 4);
System.out.println("改变前");
print("src = ", src);
print("dest = ", dest);
src[0][0] = 11111;
System.out.println("改变后");
print("src = ", src);
print("dest = ", dest);
}
// 简单输出二维int数组的方法
private static void print(String string, int[][] arr) {
System.out.print(string);
for (int[] a : arr) {
for (int i : a) {
System.out.print(i + " ");
}
System.out.print(",");
}
System.out.println();
}
}
/*
改变前
src = 1 2 ,3 4 ,5 6 ,7 8 ,
dest = 1 2 ,3 4 ,5 6 ,7 8 ,
改变后
src = 11111 2 ,3 4 ,5 6 ,7 8 ,
dest = 11111 2 ,3 4 ,5 6 ,7 8 ,
*/
源数组改变后,目标数组也跟改变了,这就是浅复制
3. 一维数组,元素为引用类型
public class SystemArrayCopy {
public static void main(String[] args) {
People p1 = new People(11, "A");
People p2 = new People(12, "B");
People p3 = new People(13, "C");
People p4 = new People(14, "D");
People[] src = new People[]{p1, p2, p3, p4};
People[] dest = new People[4];
System.arraycopy(src, 0, dest, 0, 4);
System.out.println("改变前");
print("src = ", src);
print("dest = ", dest);
src[0].setAge(111);
src[0].setName("AAA");
System.out.println("改变后");
print("src = ", src);
print("dest = ", dest);
}
private static void print(String string, People[] arr) {
System.out.print(string);
for (People p : arr) {
System.out.print(p + ", ");
}
System.out.println();
}
}
public class People {
private int age;
private String name;
// get set constructor toString
}
/*
改变前
src = People{age=11, name='A'}, People{age=12, name='B'}, People{age=13, name='C'}, People{age=14, name='D'},
dest = People{age=11, name='A'}, People{age=12, name='B'}, People{age=13, name='C'}, People{age=14, name='D'},
改变后
src = People{age=111, name='AAA'}, People{age=12, name='B'}, People{age=13, name='C'}, People{age=14, name='D'},
dest = People{age=111, name='AAA'}, People{age=12, name='B'}, People{age=13, name='C'}, People{age=14, name='D'},
*/
源数组改变后,目标数组也跟改变了,这就是浅复制
总结:只有数组为一维数组,并且元素为基本类型或String类型时,才是深复制,其它都属于浅复制
下图是System.arraycopy()复制的过程
异常
ArrayIndexOutOfBoundsException ArrayStoreException NullPointerException
1. ArrayIndexOutOfBoundsException
当数组越界时,抛出异常:ArrayIndexOutOfBoundsException
srcPos < 0 || destPos < 0 || length < 0
src.length < length + srcPos
dest.length < length + destPos
代码演示
// 1. srcPos < 0 || destPos < 0 || length < 0
public class SystemArrayCopy {
public static void main(String[] args) {
int[] src = {1, 2, 3, 4};
int[] dest = new int[5];
System.arraycopy(src, -1, dest, 0, 0);
for (Object o : dest) {
System.out.println(o);
}
}
}
/*
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
at java.lang.System.arraycopy(Native Method)
at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/
// 2. src.length < length + srcPos
public class SystemArrayCopy {
public static void main(String[] args) {
int[] src = {1, 2, 3, 4};
int[] dest = new int[5];
System.arraycopy(arr, 1, dest, 0, 4);
for (Object o : dest) {
System.out.println(o);
}
}
}
/*
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
at java.lang.System.arraycopy(Native Method)
at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/
// 3. dest.length < length + destPos
public class SystemArrayCopy {
public static void main(String[] args) {
int[] src = {1, 2, 3, 4};
int[] dest = new int[3];
System.arraycopy(src, 0, dest, 0, 4);
for (Object o : dest) {
System.out.println(o);
}
}
}
/*
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
at java.lang.System.arraycopy(Native Method)
at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/
2. ArrayStoreException
当两数据的元素类型不匹配时,抛出异常:ArrayStoreException
src元素为dest元素的子类时,是可以复制的,特殊地,int不是Object的子类(或者说,不存在继承的概念),所以,下例中,把int[] src = {1, 2, 3, 4};改为Integer[] src = {1, 2, 3, 4};,是不会报错的
public class SystemArrayCopy {
public static void main(String[] args) {
int[] src = {1, 2, 3, 4};
Object[] dest = new Object[3];
System.arraycopy(src, 0, dest, 0, 4);
for (Object o : dest) {
System.out.println(o);
}
}
}
/*
Exception in thread "main" java.lang.ArrayStoreException
at java.lang.System.arraycopy(Native Method)
at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/
public class SystemArrayCopy {
public static void main(String[] args) {
Object[] src = {1, 2, 3, 4};
int[] dest = new int[3];
System.arraycopy(src, 0, dest, 0, 4);
for (Object o : dest) {
System.out.println(o);
}
}
}
/*
Exception in thread "main" java.lang.ArrayStoreException
at java.lang.System.arraycopy(Native Method)
at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/
3. NullPointerException
当两个数组,有一个为null时,抛出异常:NullPointerException
public class SystemArrayCopy {
public static void main(String[] args) {
int[] src = {1, 2, 3, 4};
int[] dest = null;
System.arraycopy(src, 0, dest, 0, 4);
for (Object o : dest) {
System.out.println(o);
}
}
}
/*
Exception in thread "main" java.lang.NullPointerException
at java.lang.System.arraycopy(Native Method)
at com.balsam.sources.SystemArrayCopy.main(SystemArrayCopy.java:13)
*/
最后关于几种数组复制的效率问题
1、for循环,手动复制
2、System.arraycopy()方法
3、Arrays.copyOf()方法
4、clone()方法
结论:
由于System.arraycopy()是最贴近底层的,其使用的是内存复制,省去了大量的数组寻址访问等时间,故效率最高。
对于Arrays.copyOf()方法查看源码可以看到:
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;
}
它是借助System.arraycopy()方法实现的,故效率次于System.arraycopy()
clone()方法效率是最低的,一般需要重写,clone的方法Object执行特定的克隆操作。 首先,如果此对象的类不实现接口Cloneable ,则抛出CloneNotSupportedException 。 请注意,所有数组都被认为是实现接口Cloneable ,并且数组类型T[]的clone方法的返回类型是T[] ,其中T是任何引用或原始类型。 否则,该方法将创建该对象的类的新实例,并将其所有字段初始化为完全符合该对象的相应字段的内容,就像通过赋值一样。 这些字段的内容本身不被克隆。 因此,该方法执行该对象的“浅拷贝”,而不是“深度拷贝”操作。如果需要“深度拷贝”操作,则需要递归clone()。
对于数组空间小的情况下,前三种差别不大,对于比较大的数组,便可以明显看出差别。
参考文章:
System.arraycopy()方法详解_qq_32440951的博客-CSDN博客_system.arraycopy
System.arraycopy()方法详解-jdk1.8_balsamspear的博客-CSDN博客_system.arraycopy