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