java面试题26 java语言的下面几种数组复制方法中，哪个效率最高？
A for 循环逐一复制B System.arraycopyC Array.copyOfD 使用clone方法效率：System.arraycopy > clone > Arrays.copyOf > for循环
1、System.arraycopy的用法：public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)参数：src - 源数组。srcPos - 源数组中的起始位置。dest - 目标数组。destPos - 目标数据中的起始位置。length - 要复制的数组元素的数量
应用实例：
public class Main{ public static void main(String[] args) { int[] a1={1,2,3,4,5,6}; int[] a2={11,12,13,14,15,16}; System.arraycopy(a1, 2, a2, 3, 2); System.out.print("copy后结果："); for(int i=0;i<a2.length;i++){ System.out.print(a2[i]+" "); } } }运行结果：
2、clone 的用法：
java.lang.Object类的clone()方法为protected类型，不可直接调用，需要先对要克隆的类进行下列操作：
首先被克隆的类实现Cloneable接口；然后在该类中覆盖clone()方法，并且在该clone()方法中调用super.clone()；这样，super.clone()便可以调用java.lang.Object类的clone()方法。
应用实例：
//被克隆的类要实现Cloneable接口 class Cat implements Cloneable { private String name; private int age; public Cat(String name,int age) { this.name=name; this.age=age; } //重写clone()方法 protected Object clone()throws CloneNotSupportedException{ return super.clone() ; } } public class Clone { public static void main(String[] args) throws CloneNotSupportedException { Cat cat1=new Cat("xiaohua",3); System.out.println(cat1); //调用clone方法 Cat cat2=(Cat)cat1.clone(); System.out.println(cat2); } }3、复制引用和复制对象的区别
复制引用：是指将某个对象的地址复制，所以复制后的对象副本的地址和源对象相同，这样，当改变副本的某个值后，源对象值也被改变；
复制对象：是将源对象整个复制，对象副本和源对象的地址并不相同，当改变副本的某个值后，源对象值不会改变；
Cat cat1=new Cat("xiaohua",3);//源对象 System.out.println("源对象地址"+cat1); //调用clone方法，复制对象 Cat cat2=(Cat)cat1.clone(); Cat cat3=(Cat)cat1;//复制引用 System.out.println("复制对象地址："+cat2); System.out.println("复制引用地址："+cat3);输出结果：
可以看出，复制引用的对象和源对象地址相同，复制对象和源对象地址不同4、Arrays.copyOf 的用法：
Arrays.copyOf有十种重载方法，复制指定的数组，返回原数组的副本。具体可以查看jdk api
背后原理探究
首先要申明的是这4种方法中的前3种是没有本质区别的，对象都是浅复制(复制地址)，而普通类型都是深复制(复制值)，简单来说
浅复制：复制地址，相当于复制了房子(内存数据)的钥匙,一改全改
深复制：复制值，通俗意义上的拷贝，相当于建了一个一模一样的房子(内存的数据)
接下来说说3种方式：
System.arraycopy()源码如下:
@HotSpotIntrinsicCandidate public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);可以看到这是一个native(本地)方法,也就是说是用C++写的,所以其效率比非native方法更高
但更要注意的是上面的注解@HotSpotIntrinsicCandidate，我们来看官方对这个注解的解释
* The {@code @HotSpotIntrinsicCandidate} annotation is specific to the * HotSpot Virtual Machine. It indicates that an annotated method * may be (but is not guaranteed to be) intrinsified by the HotSpot VM. A method * is intrinsified if the HotSpot VM replaces the annotated method with hand-written * assembly and/or hand-written compiler IR -- a compiler intrinsic -- to improve * performance. The {@code @HotSpotIntrinsicCandidate} annotation is internal to the * Java libraries and is therefore not supposed to have any relevance for application * code.注意红字粗体所说,为了提升性能,在JVM里对该注解的进行了手写,这里要提一个叫JNI(Java Native Interface)的东西,普通的native方法通俗的讲就是编译后还要通过JNI再次编译成.cpp文件才能执行.而有 @HotSpotIntrinsicCandidate这个注解的方法在JVM里就是用.cpp文件写好的,所以就跳过了JNI阶段,所以速度就能提升,这也是System.arraycopy()速度冠绝群雄的原因.
Object.clone()源码如下：
@HotSpotIntrinsicCandidate protected native Object clone() throws CloneNotSupportedException;可以看到它也是native方法，也有@HotSpotIntrinsicCandidate注解，那为啥速度比上面的大哥慢呢？这就要看到官方解释的一句
It indicates that an annotated method may be (but is not guaranteed to be) intrinsified by the HotSpot VM注意用词：may be (but is not guaranteed to be)，是的，clone()方法就是悲催的but，它并没有被手工写在JVM里面，所以它不得不走JNI的路子，所以它就成了2哥。
Arrays.copyof()源码如下
@HotSpotIntrinsicCandidate public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) { @SuppressWarnings("unchecked") T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength] : (T[]) Array.newInstance(newType.getComponentType(), newLength); System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }3弟也有注解 @HotSpotIntrinsicCandidate，但它甚至不是native方法，所以这个注解也就是混子，也更印证了2哥的待遇，
而且可以很明显的看到里面本质是调用了大哥 System.arraycopy()来实现的，所以效率垫底也是妥妥的。
for()这个就可以退出群聊吧！for(）无论是基本数据类型还是引用数据类型统统是深复制，而且其也不是封装的函数，所以退出群聊妥妥的。
最后上测试代码，有兴趣的可以看看：package 问题;
import java.util.Arrays; public class CopySpeed implements Cloneable { /* * * 数组复制速度 1.System.arraycopy() 2.clone() 3.Arrays.copyof() 4.for() * * * */ int i = 0; String value = "123"; /* * 基本数据类型测试 * * */ public long[] CopySpeedTest(int[] t) { /* * 初始化所有 * */ int length = t.length; int[] systemCopy = new int[t.length]; int[] clone = new int[t.length]; int[] arraysCopyOf = new int[t.length]; int[] For = new int[t.length]; /* * 执行复制操作,并统计时间 * */ long begin = System.currentTimeMillis(); System.arraycopy(t, 0, systemCopy, 0, t.length); long end = System.currentTimeMillis(); long arraycopyTimes = end - begin; begin = System.currentTimeMillis(); clone = t.clone(); end = System.currentTimeMillis(); long cloneTimes = end - begin; begin = System.currentTimeMillis(); arraysCopyOf = Arrays.copyOf(t, t.length); end = System.currentTimeMillis(); long arraysCopyOfTimes = end - begin; /* * 为了方便查看,这里设定下面程序只执行一次 * */ if (i == 0) { /* * 查看哈希值 */ System.out.println("t:\t" + t.hashCode()); System.out.println("systemCopy:\t" + systemCopy.hashCode()); System.out.println("clone:\t" + clone.hashCode()); System.out.println("arraysCopyOf:\t" + arraysCopyOf.hashCode()); i++; } /* * 运行时间统计 * */ long[] times = new long[3]; times[0] = arraycopyTimes; times[1] = cloneTimes; times[2] = arraysCopyOfTimes; return times; } /* * * 引用数据类型结果 * * */ public long[] CopySpeedTest(CopySpeed[] t) { /* * 初始化所有 * */ int length = t.length; CopySpeed[] systemCopy = new CopySpeed[length]; CopySpeed[] clone = new CopySpeed[length]; CopySpeed[] arraysCopyOf = new CopySpeed[length]; /* * 执行复制操作,并统计时间 * */ long begin = System.currentTimeMillis(); System.arraycopy(t, 0, systemCopy, 0, t.length); long end = System.currentTimeMillis(); long arraycopyTimes = end - begin; begin = System.currentTimeMillis(); clone = t.clone(); end = System.currentTimeMillis(); long cloneTimes = end - begin; begin = System.currentTimeMillis(); arraysCopyOf = Arrays.copyOf(t, t.length); end = System.currentTimeMillis(); long arraysCopyOfTimes = end - begin; /* * 为了方便查看,这里设定下面程序只执行一次 * */ if (i == 1) { /* * 查看哈希值 */ System.out.println("t[0]:\t" + t[0].hashCode()); System.out.println("systemCopy[0]:\t" + systemCopy[0].hashCode()); System.out.println("clone[0]:\t" + clone[0].hashCode()); System.out.println("arraysCopyOf[0]:\t" + arraysCopyOf[0].hashCode()); /* * 修改新对象的值来判断是浅复制还是深复制 * */ System.out.println("深浅复制判断,以value属性判断"); System.out.println("修改前t[0]:\t" + t[0].value); System.out.println("修改前systemCopy[0]:\t" + systemCopy[0].value); System.out.println("修改前clone[0]:\t" + clone[0].value); System.out.println("修改前arraysCopyOf[0]:\t" + arraysCopyOf[0].value); System.out.println("---------------------------"); t[0].value = "t"; systemCopy[0].value = "systemCopy"; clone[0].value = "clone"; arraysCopyOf[0].value = "arraysCopyOf"; System.out.println("修改后t[0]:\t" + t[0].value); System.out.println("修改后systemCopy[0]:\t" + systemCopy[0].value); System.out.println("修改后clone[0]:\t" + clone[0].value); System.out.println("修改后arraysCopyOf[0]:\t" + arraysCopyOf[0].value); i++; } /* * 运行时间统计 */ long[] times = new long[3]; times[0] = arraycopyTimes; times[1] = cloneTimes; times[2] = arraysCopyOfTimes; return times; } public static void main(String args[]) { CopySpeed speed = new CopySpeed(); System.out.println("基本类型"); long[] baseTimes = new long[] { 0, 0, 0 }; int[] baseArrays = new int[10000000]; for (int i = 0; i < baseArrays.length; i++) { baseArrays[i] = i; } for (int i = 0; i < 20; i++) { // System.out.print(i+"次"); long[] temp = speed.CopySpeedTest(baseArrays); baseTimes[0] += temp[0]; baseTimes[1] += temp[2]; baseTimes[2] += temp[1]; // System.out.println(); } baseTimes[0] /= 20; baseTimes[1] /= 20; baseTimes[2] /= 20; System.out.println(Arrays.toString(baseTimes)); System.out.println("引用类型"); long[] ObjectTimes = new long[] { 0, 0, 0 }; CopySpeed[] ObjectArrays = new CopySpeed[10000000]; for (int i = 0; i < ObjectArrays.length; i++) { ObjectArrays[i] = new CopySpeed(); } for (int i = 0; i < 20; i++) { // System.out.print(i+"次"); long[] temp = speed.CopySpeedTest(ObjectArrays); ObjectTimes[0] += temp[0]; ObjectTimes[1] += temp[1]; ObjectTimes[2] += temp[2]; // System.out.println(); } ObjectTimes[0] /= 20; ObjectTimes[1] /= 20; ObjectTimes[2] /= 20; System.out.println(Arrays.toString(ObjectTimes)); } }结果：
基本类型 t: 1552787810 systemCopy: 1361960727 clone: 739498517 arraysCopyOf: 125130493 [10, 14, 15] 引用类型 t[0]: 166239592 systemCopy[0]: 166239592 clone[0]: 166239592 arraysCopyOf[0]: 166239592 深浅复制判断,以value属性判断 修改前t[0]: 123 修改前systemCopy[0]: 123 修改前clone[0]: 123 修改前arraysCopyOf[0]: 123 --------------------------- 修改后t[0]: t 修改后systemCopy[0]: t 修改后clone[0]: t 修改后arraysCopyOf[0]: t [22, 31, 55]结果分析：
基本类型 t: 1552787810 systemCopy: 1361960727 clone: 739498517 arraysCopyOf: 125130493 [10, 14, 15]
对于基本数据类型可以看到4个对象的hashcode完全不同，也就验证了前面的深复制的猜想
而10，14，15的运行时间也能证明他们的效率差别，当然因为是基本数据类型，
而且数据量不算恐怖，所以差距并不大，特别是clone和arraysCopyOf
可以明显的看到，clone因为JNI的耽误，而Arrays.CopyOf因为System.Copy的加成速度也不赖。
引用类型 t[0]: 166239592 systemCopy[0]: 166239592 clone[0]: 166239592 arraysCopyOf[0]: 166239592
对于引用类型，额可以看到4个对象的hashcode值完全相同，说明指向的是同一块内存
深浅复制判断,以value属性判断 修改前t[0]: 123 修改前systemCopy[0]: 123 修改前clone[0]: 123 修改前arraysCopyOf[0]: 123 --------------------------- 修改后t[0]: t 修改后systemCopy[0]: t 修改后clone[0]: t 修改后arraysCopyOf[0]: t [22, 31, 55]
这里以对象的属性value做测试，可以看到t[0]里面的数据更改后，所有的数据都更改了，
说明3种方法对于对象都是浅复制
答案为B我是歌谣，若与不合理之处欢迎指出。喜欢敲代码，没事刷刷题。
for循环逐一复制：这个应该是比较慢的。
System.arraycopy( )：查看源码，可知 public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);
Arrays.copyof( )：本质上调用的是arraycopy( )方法，所以效率上肯定比System.arraycopy( )要低。
Clone( )方法：查看源码可知，protected native Object clone() throws CloneNotSupportedException；可以看到是native方法：native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。但是返回的是Object类型，需要强制转换。 一般用clone效率是最差的。
转载于:https://www.cnblogs.com/itaylor/p/7819344.html
java数组拷贝主要有四种方法，分别是循环赋值，System.arraycopy(),Arrays.copyOf()(或者Arrays.copyOfRange)和clone()方法。下面分别介绍一下这几种拷贝。
循环拷贝（速度相对比较慢）
循环拷贝其实没什么好说的啦，就是用一个for循环进行元素的逐个拷贝，进行深拷贝或者浅复制这个大家可以自己把握。
System.arraycopy（浅拷贝）
这个是系统提供的拷贝方式，也是我们推荐使用的拷贝方式，它是浅拷贝，也就是说对于非基本类型而言，它拷贝的是对象的引用，而不是去新建一个新的对象。通过它的代码我们可以看到，这个方法不是用java语言写的，而是底层用c或者c++实现的，因而速度会比较快。
public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);
通过源代码我们可以看到，关键字native说明它不是用java语言写的，而是调用其他语言的代码。
Arrays.copyOf（浅拷贝）
这个方法也是浅拷贝，为什么呢？我们看一下它的源代码就知道了。
public static byte[] copyOfRange(byte[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
byte[] copy = new byte[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
实际上它调用的就是System.arraycopy，所以肯定也是浅拷贝。
Object.clone
clone()比较特殊，对于对象而言，它是深拷贝，但是对于数组而言，它是浅拷贝。
对象拷贝
首先讲一下对象的拷贝，它是深拷贝，大家可以用对象去测试一下。下面我们看一下它的源代码：
protected native Object clone() throws CloneNotSupportedException;
这里也有native关键字，所以也是底层的c语言实现的。
还要注意的是，这里修饰符是protected，也就是说，我们创建了一个Object类以后，是不能直接调用这个clone（）方法的，因为protected关键字只允许同一个包内的类和它的子类调用，所以我们声明一个object类时，肯定不是同一个包内，所以就不能去调用它。
要调用这个方法，就需要我们写一个类，然后声明实现cloneable接口就好了，不需要去显示地声明继承于object，因为java中的类如果不显示说明父类的话，默认父类就是object。然后我们继承这个方法：
@Override
public Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
这里需要是，为了能够在不同包内去调用这个方法，我们需要把这个权限升级为public。现在我们就可以调用这个类的clone()方法去拷贝我们的类了。
数组拷贝
对于数组而言，它不是简单的将引用赋值为另外一个数组引用，而是创建一个新的数组。但是我们知道，对于数组本身而言，它它的元素是对象的时候，本来数组每个元素中保存的就是对象的引用，所以，拷贝过来的数组自然而言也是对象的引用，所以对于数组对象元素而言，它又是浅拷贝。我们用以下代码验证一下：
class Aby implements Cloneable{
public int i;
public Aby(int i) {
this.i = i;
}
@Override
public Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
}
public class Solution {
public static void main(String[] args) throws CloneNotSupportedException {
Aby aby1 = new Aby(1);
Aby aby2 = (Aby) aby1.clone();
aby1.i = 2;
System.out.println(aby1.i); //2
System.out.println(aby2.i); //1
Aby[] arr = {aby1,aby2};
Aby[] arr2 = arr.clone();
arr2[0].i = 3;
System.out.println(arr[0].i); //3
System.out.println(arr2[0].i); //3
}
}
java语言复制数组的四种方法
JAVA语言的下面几种数组复制方法中，哪个效率最高？
A.for循环逐一复制B.System.arraycopyC.System.copyofD.使用clone方法效率：System.arraycopy > clone > Arrays.copyOf > for循环
1、System.arraycopy的用法：
其为native方法，即原生态方法，关键字native说明它不是用java语言写的，而是调用其他语言的代码，因此效率最高
- public static void native arraycopy(Object src,
- int srcPos,
- Object dest,
- int destPos,
- int length)
参数：
src- 源数组。
srcPos- 源数组中的起始位置。
dest- 目标数组。
destPos- 目标数据中的起始位置。
length- 要复制的数组元素的数量2、clone 的用法
Object.clone从源码来看同样也是native方法，所以也是底层的C语言实现的，但返回为Object类型，所以赋值时将发生强转，所以效率不如1protected native Object clone() throws CloneNotSupportedException;例：
class Aby implements Cloneable{
public int i;
public Aby(int i) {
this.i = i;
}
@Override
public Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
}
public class Solution {
public static void main(String[] args) throws CloneNotSupportedException {
Aby aby1 = new Aby(1);
Aby aby2 = (Aby) aby1.clone();
aby1.i = 2;
System.out.println(aby1.i); //2
System.out.println(aby2.i); //1
Aby[] arr = {aby1,aby2};
Aby[] arr2 = arr.clone();
arr2[0].i = 3;
System.out.println(arr[0].i); //3
System.out.println(arr2[0].i); //3
}
}3、Arrays.copyOf 的用法：
有十种重载方法，复制指定的数组，返回原数组的副本。具体可以查看jdk api
java.util.Arrays.Arrays.copyOf(源数组,新数组长度);
java.util.Arrays.copyOfRange(源数组，开始拷贝位置，结束拷贝位置);
它的源代码
+ View code
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。
4、for循环
代码灵活，但效率低
