java數組復制的方式和效率比較

java中，數組的復制有以下三種方式：

1. 調用System.arraycopy（Arrays.copyOfRange可以當作第四種，但是底層調用的是System.arraycopy，所以，認為是同一種，下面是Arrays.copyOfRange的方法實現）

 

 public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

 

2. 調用clone方法

3.利用for循環自己實現

效率比較上，通過下面程序可以看出

 

/**
 * 
 */
package collection;

import java.util.Arrays;
import java.util.Date;

/**
 * @author yfei
 * Date:2013-8-26
 */
public class Array {
	public static final int size = 1000000;

	public static void copyByArrayCopy(String[] strArray){
		Long startTime = System.currentTimeMillis();
		String[] destArray = new String[size];
		System.arraycopy(strArray,0,destArray,0,strArray.length);
		//printArr(destArray);
		Long endTime = System.currentTimeMillis();
		System.out.println("copyByArrayCopy cost time is "+(endTime-startTime));
	}
	
	public static void copyByLoop(String[] strArray){
		Long startTime = System.currentTimeMillis();
		String[] destArray = new String[size];
		for(int i = 0;i<strArray.length;i++){
			destArray[i] = strArray[i];
		}
		//printArr(destArray);
		Long endTime = System.currentTimeMillis();
		System.out.println("copyByLoop cost time is "+(endTime-startTime));
	}
	
	public static void copyByClone(String[] strArray){
		Long startTime = System.currentTimeMillis();
		String[] destArray = strArray.clone();
		Long endTime = System.currentTimeMillis();
		System.out.println("copyByClone cost time is "+(endTime-startTime));
	}

	public static void main(String args[]){
		String arr1[] = new String[size];
		for(int i=0;i<size;i++){
			arr1[i] = "this is a test"+i;
			//arr1[i] = "shishangzhiyoumamahaoyouamdehaizixiangkuaibaotoujinmamadehuaibaoxingfuxiangbuliaoshishangzhiyoumamahaomeimadehaizixianggencaolikaimamadehuaibaoxingfunalizhaoshishangzhiyoumamahaomeimadehaizibuzhidaoyaoshitazhidaomengliyehuixiao"+i;

		}
		String arr2[] = new String[size];
		for(int i=0;i<size;i++){
			arr2[i] = "this is a test"+i;
			//arr2[i] = "shishangzhiyoumamahaoyouamdehaizixiangkuaibaotoujinmamadehuaibaoxingfuxiangbuliaoshishangzhiyoumamahaomeimadehaizixianggencaolikaimamadehuaibaoxingfunalizhaoshishangzhiyoumamahaomeimadehaizibuzhidaoyaoshitazhidaomengliyehuixiao"+i;

		}
		String arr3[] = new String[size];
		for(int i=0;i<size;i++){
			arr3[i] = "this is a test"+i;
			//arr3[i] = "shishangzhiyoumamahaoyouamdehaizixiangkuaibaotoujinmamadehuaibaoxingfuxiangbuliaoshishangzhiyoumamahaomeimadehaizixianggencaolikaimamadehuaibaoxingfunalizhaoshishangzhiyoumamahaomeimadehaizibuzhidaoyaoshitazhidaomengliyehuixiao"+i;

		}
		copyByClone(arr1);
		copyByLoop(arr2);
		copyByArrayCopy(arr3);
		
	}
	public static void printArr(String[] strArray){
		for(String str:strArray){
			System.out.println(str);
		}
	}
}

 

結果(ms單位)：

copyByClone cost time is 2
copyByLoop cost time is 352
copyByArrayCopy cost time is 3

由此可以看出，clone和arraycopy的效率基本是一致的，而通過循環copy的效率最慢。

看了一下源代碼：

clone：

 

 protected native Object clone() throws CloneNotSupportedException;

arraycopy

 

 

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

兩種方式都是用native  method。

 

簡單地講，一個Native Method就是一個java調用非java代碼的接口。一個Native Method是這樣一個java的方法：該方法的實現由非java語言實現，比如C。這個特征並非java所特有，很多其它的編程語言都有這一機制，比如在C＋＋中，你可以用extern "C"告知C＋＋編譯器去調用一個C的函數。

java的性能是不能言說的傷啊。。。