for循环逐一复制
System.arraycopy
Arrays.copyof
使用clone方法
A、for循环的话，很灵活，但是代码不够简洁.
B、System.arraycopy()源码。可以看到是native方法：native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。
可以将native方法比作Java程序同Ｃ程序的接口。
public static native void arraycopy(Object src,
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));
D。clone的话，返回的是Object【】，需要强制转换。 一般用clone效率是最差的，
CD可以排除。那么AB怎么比较呢？
给出一下参考的：
http://bbs.csdn.net/topics/。
/blog/1046621
具体的理由不好说。不过一致的说法和实验证明是arraycopy（)效率高！！！T...T
首先: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,
, Object dest, int destPos,
int length);
C：Arrays.copyOf底层调用了上面的System.copyOf效率比上面两个低。
D：clone()的完整定义：protected native Object clone() throws CloneNotSupportedE
高票答案说的clone()返回的是Object类型，其实是错误的，只有Object[]数组的clone()方法才返回Object类型，子类重写了父类的方法。
其实，一般情况下，前三个的效率差别几乎忽略不计，但是从Arrays.copyOf底层调用的是System.arraycopy，自然System.arrayCopy效率自然要低一些。
而clone()和System.arraycopy只是从实验的结果来看是System.arraycopy的效率高。
只知道for循环，但是我做对了
因为一看效率最高的肯定是system最底层的方法嘛
借鉴楼下，从c++/c的角度来看，数组的复制就是对某块内存的复制，直接和内存打交道的是最快的
至于for循环为什么慢，java中所以的变量都是引用，就其本身来说实在栈区，而申请的空间（也就是new）在堆中，所以一来一回，就会导致java中for循环变慢。
native方法使用场景：
1、使用java操纵硬件；
2、调用C/C++;
直接移动指针，改变数组大小应该是最快的吧。System.arrycopy()的底层实现估计就是这样。
活到老学到老
我想知道CD两个，哪个效率更好？
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. 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 & i++){
strArray[i] = &abc&;
copyByClone(strArray);
copyByLoop(strArray);
copyByArrayCopy(strArray);
copyByCopyof(strArray);
copyByClone cost time is 10263
copyByLoop cost time is 1642
copyByArrayCopy cost time is 6158
copyByCopyof cost time is 58294
copyByClone cost time is 201980
copyByLoop cost time is 2340831
copyByArrayCopy cost time is 284496
copyByCopyof cost time is 323086
copyByClone cost time is 3116729
copyByLoop cost time is 8657626
copyByArrayCopy cost time is
copyByCopyof cost time is 2423348
你们可以写代码试试，并不像有人评论的是说无数次实验结果都是哪个性能最高。所以我也弄得不是太明白，希望大神给解答。
System.arraycopy底层是调用的其他语言编写的复制逻辑，速度比较快！
效率：System.arraycopy & clone & Arrays.copyOf & for循环
一般clone效果最差 for代码没有arrayCopy好 copyOf是Arrays的方法本质上调用的是arrayCopy方法
arraycopy(Object src,
Object dest, int
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
该方法是用了native关键字，调用的为C++编写的底层函数，可见其为JDK中的底层函数。
[] copyOf(
[] original,
newLength) {
[newLength];
System.arraycopy(original, 0
Math.min(original.length, newLength));
original-源数组
newLength-copy长度，目标数组的长度会根据该值改变
Arrays.copyof 方法 调用了 System.arracopy
System.arraycopy＞clone＞Arrays.copyOf＞for
System.arraycopy & clone &
Arrays.copyOf & for循环
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));
arraycopy : 83
copyOf : 270
clone : 355
我试了下，for循环和arraycopy不相上下，都比其他两个快几倍
A、for循环的话，很灵活，但是代码不够简洁.
B、System.arraycopy()源码。可以看到是native方法：native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。 可以将native方法比作Java程序同Ｃ程序的接口。
public static native void arraycopy(Object src,
Object dest, int destPos,int length);
C、选项有误，copyOf不是System的方法，而是Arrays的方法，下面是源码，可以看到本质上是调用的arraycopy方法。，那么其效率必然是比不上 arraycopy的
publicstaticint[] copyOf(int[] original, intnewLength) {
int[] copy = newint[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
D。clone的话，返回的是Object【】，需要强制转换。
一般用clone效率是最差的，
System.arraycopy()查看源码就知道，可以看到是static
native void 是一个本地方法，类似抽象方法，调用的是底层c语言的对应的方法。
这道题你会答吗？花几分钟告诉大家答案吧！
扫描二维码，关注牛客网
下载牛客APP，随时随地刷题
浙ICP备号-2
扫一扫，把题目装进口袋博客分类：
今天在研究Jlibrtp代码时，偶然注意到里面大量使用了System.arraycopy()这个方法，心想既然是协议实现，那用的方法肯定都是效率最高或较高的了，以前对这个System.arraycopy()仅有个抽象的认识。另外，JDK中对ArrayList的add与remove方法的实现，居然也是用的System.arraycopy()，让我不由得对其产生“敬意啊”。今天就来动手试一下到底谁的效率高，到底有多高。
C程序员们经常讨论数组复制的效率，此类笔试面试题也层出不穷。在Java中，数组拷贝可以用：1）for循环；2）clone方法；3）System.arraycopy()。测试如下：
（1）使用了一个70元素的字符串数组；
（2）每种方法各循环拷贝N次。
统计结果如下：
重复1000次
System.arraycopy
很明显了，for循环最慢，约为clone方法的2倍，约为System.arraycopy的4~5倍；System.arraycopy最快。
PS：System.arraycopy是调用的JNI，怪不得。
附测试代码：
public class ArrayCopyTest
private static String [] src
= {"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff",
"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff",
"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff",
"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff",
"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff",
"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff",
"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff",
"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff",
"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff",
"Aaaaaaaaaa", "Vvvvvvv", "Bbbb", "Cccc", "Dddd", "Eddeee", "FFFFFFffffffff"};
private static String []
* @param args
public static void main(String[] args)
// TODO Auto-generated method stub
System.out.println(forCopy(5000000));
System.out.println(cloneCopy(5000000));
System.out.println(systemJNICopy(5000000));
* 使用for来复制数组
* @param time 循环执行的次数
* @return 执行的总时间
public static long forCopy(int time)
long start = System.currentTimeMillis();
while(time-- & 0)
int size = src.
dst = new String [size];
for (int i = 0; i & i++)
dst[i] = src[i];
long end = System.currentTimeMillis();
return (end - start);
public static long cloneCopy(int time)
long start = System.currentTimeMillis();
while(time-- & 0)
dst = (String[])src.clone();
long end = System.currentTimeMillis();
return (end - start);
public static long systemJNICopy(int time)
long start = System.currentTimeMillis();
while(time-- & 0)
int size = src.
System.arraycopy(src, 0, dst, 0, size);
long end = System.currentTimeMillis();
return (end - start);
浏览: 17131 次
来自: 南京
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'相关文章推荐
先看ArrayList源码中数组复制的代码:
其实ArrayList 就是一个数组的形式存放数据的. 没有高深的地方.他的性能在于他的索引能力, 正因为他是数组形式,所以索引元素的时候他表...
java 数组复制:System.arrayCopy 深入解析
( 17:02:17)
system
...
今天作者就Java数组的拷贝方法进行性能比较，多有不足，请大家指正！！！
1.for方法，用循环依次实现数组元素的拷贝。
2.clone方法，是Object类的方法，用来实现对象的复制操作。
今天看了下ArrayList的源码，其中许多方法要用到数组的复制，而且全部使用的是System.arraycopy方法
public static native void arraycopy(O...
如果是复制一个一位数组，那么改变复制后的数组并不影响原数组。但是如果复制一个二维数组，那么改变其中任何一个数组，那么另一个的值也发生了变化。开始不是很明白，后来上网查了查资料，理解了其中奥妙。
System.arraycopy 整块内存拷贝,效率高;
参考:Java 数组复制System.arraycopy性能分析
为了避免内存不稳定干扰和运行的偶然性结果，我在一开始的时候把所有空间申明...
import java.util.A
public class LessionSystemArraycopy {
public static void main(...
import java.util.A
* System.arraycopy方法的使用。
* 从指定源数组中复制一个数组，复制从指定的位置开始，
* 到目标数组的...
java.lang.System的静态方法arraycopy()可以实现数组的复制，这个方法效率比较高，如果数组有成千上万个元素，那么用这个方法，比用for语句循环快不少。
public st...
今天在看hbase源码，看到了System.arraycopy方法，学习了一下：
java中的ArrayList是动态数组，其优点就是查询速度快，插入和删除速度慢，就是因为它是数组形式，有位置索引，...
他的最新文章
他的热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)本帖子已过去太久远了，不再提供回复功能。java System.arraycopy方法的问题_百度知道
java System.arraycopy方法的问题
public static void main(String[] args) {
int[] a={1,2,3,4,5};
int[] b=new int[10];
for (int i : b) {
System.arraycopy(a, 1, b, 0,4);
for (int i : b) {
System.out.println(b[i]);
我想把1~5 复制到...
我有更好的答案
int srcPos.arraycopy(a;最后修改后的代码如下，我已经测试过了。, b, 0;这个应该改为System.arraycopy(a, 0,
int length)参数：src - 源数组。srcPos - 源数组中的起始位置.
for (int i ，执行的都是同一条语句b[0] = 0;如果是 for (int i : b) {
b[i]=1; }只有b[0] = 1。
for (int i : b) {
System.out.println(b[i]);这个应该改成
for (int i : b) {
System.out.println(i);
for (int i : b) {
System。 for (int i : b) {
b[i]=0; }这样的赋值是不对的。。dest - 目标数组。public static void main(String[] args) {
int[] a={1: b) {
System.arraycopy(a,3。仍有问题可以HI我, 1, b, 0,5)。。,4,5};
int[] b=new int[10],5);否则只能复制2~5public static void arraycopy(Object src, 其它的都是0System。。。destPos - 目标数据中的起始位置。length - 要复制的数组元素的数量，而for (int i : b)表示的意思是依次取b中的每个值, 0, b。。数组b 的初值都是0, 0,4).print(i);
}希望对你有帮助。，而b里面的值都是0,
Object dest,
int destPos有几个小问题哦。，所以无论循环多少次。。,2
采纳率：48%
为您推荐：
其他类似问题
您可能关注的内容
java的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。