System.arraycopy详解

说道数组的复制，最经常使用的应该就是弄个循环挨个赋值，或是直接clone了。但其实还有System.arraycopy这样的方法，而且速度更快。

多说无用，直接代码测试一下~

int size = 10000;

int[] res = new int[size];

int[] to = new int[size];

long t = System.nanoTime();

for (int i = 0; i < size; i++) {

to[i] = res[i];

}

t = System.nanoTime()-t;

System.out.println("for:"+t);

t = System.nanoTime();

to = res.clone();

t = System.nanoTime()-t;

System.out.println("clone:"+t);

t = System.nanoTime();

System.arraycopy(res, 0, to, 0, size);

t = System.nanoTime()-t;

System.out.println("sys copy:"+t);

输出结果：

for:147630

clone:30789

sys copy:7894

结论：System.arraycopy明显快于其他2中方法，而且clone要快于for。

下面用10w、100w、1000w再测一遍：

10w：

for:1895112

clone:220261

sys copy:72236

100w：

for:7529924

clone:2160373

sys copy:1111962

1000w：

for:18103632

clone:21056234

sys copy:11426726

结论：size在达到1000w的时候，clone耗费的时间比for还要长，而System.arraycopy明显都比其余2中方法要快。

但这只是在size很大的状况下，接下来我用十、100、1000又测了一下，又发现了有趣的现象：

10：

for:395

clone:4737

sys copy:2763

100：

for:1579

clone:8684

sys copy:5526

1000：

for:14211

clone:10658

sys copy:5527

结论：能够看到，在size为十、100的时候for循环快的飞起~而在size到了1000后System.arraycopy才明显快了些。

总结：在数组的size很大的时候，考虑使用System.arraycopy来提升效率，而在size比较小的时候，能够直接使用for循环。但因为nanoTime获取的是纳秒级别的，一纳秒至关于一秒的10亿分之一，因此在虽然在十、100的时候for更快，但也只快了0.002五、0.004毫秒，没错是“毫秒”！这几乎能够忽略不计了~相较之下在10w、100w、1000w下相差了一、六、7毫秒，这虽然对咱们人类来讲也是没啥区别，但对于计算器来讲仍是有些差异的。

因此综上所述，建议使用System.arraycopy，而且System.arraycopy还能够选择性的copy数组，这里我就很少说了，直接看下面的代码跟运行的结果就懂了~~

int[] res = new int[]{0,1,2,3,4};

int[] to = new int[]{5,6,7,8,9};

ss(res);

ss(to);

System.arraycopy(res, 0, to, 0, 5);

System.out.println("--copy整个数组");

ss(to);

System.arraycopy(res, 1, to, 2, 3);

System.out.println("--copy 源数组1开始3个数 到to的2开始3个数");

ss(to);

int[] to2 = new int[]{6,6,6,6,6,6,6,6,6,6};

System.arraycopy(res, 0, to2, 1, 5);

System.out.println("--copy源数组到不一样长度的数组的1开始5个数");

ss(to2);

//注：ss是将数组打印出来的方法。

运行结果：

0 1 2 3 4 

5 6 7 8 9 

--copy整个数组

0 1 2 3 4 

--copy 源数组1开始3个数 到to的2开始3个数

0 1 1 2 3 

--copy源数组到不一样长度的数组的1开始5个数

6 0 1 2 3 4 6 6 6 6