JAVA语言的下面几种数组复制方法中，哪个效率最高？_美团笔试题

yql

A、for循环的话，很灵活，但是代码不够简洁.

B、System.arraycopy()源码。可以看到是native方法：native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。可以将native方法比作Java程序同Ｃ程序的接口。

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

C、选项有误，copyOf不是System的方法，而是Arrays的方法，下面是源码，可以看到本质上是调用的arraycopy方法。，那么其效率必然是比不上 arraycopy的

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;
}

D。clone的话，返回的是Object【】，需要强制转换。一般用clone效率是最差的，

CD可以排除。那么AB怎么比较呢？

给出一下参考的：

http://bbs.csdn.net/topics/370151185。

http://xuyuanshuaaa.iteye.com/blog/1046621 java的system.arraycopy（）方法

具体的理由不好说。不过一致的说法和实验证明是arraycopy（)效率高！！！T...T

编辑于 2015-09-15 22:19:16 回复(12)

小牛快跑233

首先:Sytem.copyOf有这个？我只知道是Arrays.copyOf

结论：

效率：System.arraycopy > clone > Arrays.copyOf > for循环

理由：

A：for循环，效率最低，随便写个程序验证一下，效率慢的不是一点.....我测试的时候比clone和System.arraycopy差了100多倍

B：System.arraycopy：原型是

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

C：Arrays.copyOf底层调用了上面的System.copyOf效率比上面两个低。

D：clone()的完整定义：protected native Object clone() throws CloneNotSupportedException;

高票答案说的clone()返回的是Object类型，其实是错误的，只有Object[]数组的clone()方法才返回Object类型，子类重写了父类的方法。

其实，一般情况下，前三个的效率差别几乎忽略不计，但是从Arrays.copyOf底层调用的是System.arraycopy，自然System.arrayCopy效率自然要低一些。

而clone()和System.arraycopy只是从实验的结果来看是System.arraycopy的效率高。

编辑于 2016-11-21 22:07:14 回复(7)

azurewer

只知道for循环，但是我做对了

因为一看效率最高的肯定是system最底层的方法嘛

发表于 2017-06-26 16:13:44 回复(4)

如果大雄没有机器猫

借鉴楼下，从c++/c的角度来看，数组的复制就是对某块内存的复制，直接和内存打交道的是最快的

至于for循环为什么慢，java中所以的变量都是引用，就其本身来说实在栈区，而申请的空间（也就是new）在堆中，所以一来一回，就会导致java中for循环变慢。

发表于 2016-04-12 14:02:07 回复(0)

天弈

int[] src = new int[1024 * 1024 * 100]; int[] dest = new int[1024 * 1024 * 100]; for (int i = 0; i < src.length; i++) {
    src[i] = i; } long startTime = System.currentTimeMillis(); for (int i = 0; i < src.length; i++) {
    dest[i] = src[i]; } long endTime = System.currentTimeMillis(); System.out.println("for : " + (endTime - startTime));  startTime = System.currentTimeMillis(); System.arraycopy(src, 0, dest, 0, src.length); endTime = System.currentTimeMillis(); System.out.println("arraycopy : " + (endTime - startTime));  startTime = System.currentTimeMillis(); dest = Arrays.copyOf(src, src.length); endTime = System.currentTimeMillis(); System.out.println("copyOf : " + (endTime - startTime));  startTime = System.currentTimeMillis(); dest = src.clone(); endTime = System.currentTimeMillis(); System.out.println("clone : " + (endTime - startTime));

for : 96

arraycopy : 83

copyOf : 270

clone : 355

我试了下，for循环和arraycopy不相上下，都比其他两个快几倍

求解答

发表于 2016-12-07 00:54:25 回复(2)

眼泪滑过所有的梦

https://blog.csdn.net/qq_33591903/article/details/82532626

里面有比较详细的情况讨论

发表于 2018-09-08 21:11:49 回复(0)

绿手

没说深复制还是浅复制啊，我要深复制的话，不还是得用for一个个来？

发表于 2019-01-22 10:33:20 回复(0)

平心静气修炼ing

 public class ArrayCopyTest {
 // size = 10;
 // size = 100000;
 public static final int size = 1000000;
 public static void copyByClone(String[] strArray){
  long startTime = System.nanoTime();
  String[] destArray = strArray.clone();  
  long endTime = System.nanoTime();
  System.out.println("copyByClone cost time is "+(endTime - startTime));
 }
 public static void copyByLoop(String[] strArray){
  long startTime = System.nanoTime();
  String[] destArray = new String[size];
  for (int i = 0; i < strArray.length; i++){
   destArray[i] = strArray[i];
  }
  long endTime = System.nanoTime();
  System.out.println("copyByLoop cost time is "+(endTime - startTime));
 }
 public static void copyByArrayCopy(String[] strArray){
  long startTime = System.nanoTime();
  String[] destArray = new String[size];
  System.arraycopy(strArray, 0, destArray, 0, strArray.length);
  long endTime = System.nanoTime();
  System.out.println("copyByArrayCopy cost time is "+(endTime - startTime));
 }
 public static void copyByCopyof(String[] strArray){
  long startTime = System.nanoTime();
  String[] destArray = Arrays.copyOf(strArray, strArray.length);
  long endTime = System.nanoTime();
  System.out.println("copyByCopyof cost time is "+(endTime - startTime));
 }
 public static void main(String[] args) {
  // TODO Auto-generated method stub  
  String[] strArray = new String[size];
  for (int i = 0; i < size; i++){
   strArray[i] = "abc";
  }
  copyByClone(strArray);
  copyByLoop(strArray);
  copyByArrayCopy(strArray);
  copyByCopyof(strArray);  
 }
}
/*
result:
copyByClone cost time is 10263
copyByLoop cost time is 1642
copyByArrayCopy cost time is 6158
copyByCopyof cost time is 58294
*/
/*
result：
copyByClone cost time is 201980
copyByLoop cost time is 2340831
copyByArrayCopy cost time is 284496
copyByCopyof cost time is 323086
*/
result:
copyByClone cost time is 3116729
copyByLoop cost time is 8657626
copyByArrayCopy cost time is 11609734
copyByCopyof cost time is 2423348

你们可以写代码试试，并不像有人评论的是说无数次实验结果都是哪个性能最高。所以我也弄得不是太明白，希望大神给解答。

发表于 2017-06-09 10:40:07 回复(1)

zzd007

System.arraycopy（native方法） > clone > Arrays.copyOf（底层调用System.arraycopy） > for循环逐个复制

发表于 2019-10-23 19:05:44 回复(0)

AtInfinity

A、for循环的话，很灵活，但是代码不够简洁.

B、System.arraycopy()源码。可以看到是native方法：native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。可以将native方法比作Java程序同Ｃ程序的接口。

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

C、选项有误，copyOf不是System的方法，而是Arrays的方法，下面是源码，可以看到本质上是调用的arraycopy方法。，那么其效率必然是比不上 arraycopy的

1

2

3

4

5

6

publicstaticint[] copyOf(int[] original, intnewLength) {

int[] copy = newint[newLength];

System.arraycopy(original, 0, copy, 0,

Math.min(original.length, newLength));

returncopy;

}

D。clone的话，返回的是Object【】，需要强制转换。一般用clone效率是最差的，

CD可以排除。那么AB怎么比较呢？

给出一下参考的：

http://bbs.csdn.net/topics/370151185。

http://xuyuanshuaaa.iteye.com/blog/1046621 java的system.arraycopy（）方法

具体的理由不好说。不过一致的说法和实验证明是arraycopy（)效率高！！！T...T

发表于 2019-09-30 07:30:43 回复(0)

super9du

直接把数组A赋值给A不是更快吗？这个有什么用？

发表于 2019-09-17 19:08:10 回复(0)

没有昵称94

没学过

发表于 2019-06-18 00:05:28 回复(0)

不做人了

特殊处理优于一般处理

发表于 2019-04-20 15:54:34 回复(0)

努力的noob

System.arraycopy＞clone＞Arrays.copyOf＞for

发表于 2019-03-25 01:18:11 回复(0)

Rogerofit

https://blog.csdn.net/qq_33591903/article/details/82532626 里面有比较详细的情况讨论

发表于 2019-03-14 23:43:26 回复(0)

为了更好的明天而战

for增强型循环 arraycop属于系统底层的方法 clone属于object类的方法需要类型转换效率最高的肯定是底层的

发表于 2019-02-10 00:14:12 回复(0)

画里探花

在比较bc实际差不多用的是同一方法，效率应该大体一致，于是选了d

发表于 2018-11-28 09:59:34 回复(0)

宋佑廉

System.arraycopy方法可以理解为系统底层的方法,操作起来当然更加快一些

发表于 2018-10-30 15:05:05 回复(0)

牛客-凌凌漆

只需要记住System.arraycopy调用了底层，速度最快；

for方法最慢，clone>array.copyOf 即可

发表于 2018-09-20 11:14:17 回复(0)

柚子皮Uzipi

非要说哪个快，当然是越底层的实现越快。System.arraycopy 是 native 方法，效率最高。clone() 一般是效率比较差的。

发表于 2018-02-24 16:17:28 回复(0)

JAVA语言的下面几种数组复制方法中，哪个效率最高？

问题信息

热门推荐

相关试题