JavaScript和Java数组拷贝各种方法耗时比较

Java数组复制方法耗时比较，先上代码：

import java.util.Arrays;

/**
 * Created by jxr202 on 2017/10/13
 */
public class ArraysCopyCompare {

	// 初始化50000个元素的数组
	static int[] array = new int[50000];
    static {
        for (int i = 0; i < array.length; i ++) {
            array[i] = (int) (10000 * Math.random());
        }
    }
    
    public static void main(String args[]) {
    	long time1 = 0, time2 = 0, time3 = 0, time4 = 0;
    	for (int i = 0; i < 5; i ++) {    		
    		time1 += method1();
    		time2 += method2();
    		time3 += method3();
    		time4 += method4();
    	}
    	System.out.println("time1: " + time1 + ", time2: " + time2 + ", time3: " + time3 + ", time4: " + time4);
    }

    // 使用For循环复制数组,效率太低
    static long method1() {
    	long time = System.currentTimeMillis();
    	int[] arrayTemp = new int[array.length];
    	for (int i = 0; i < array.length; i ++) {
    		arrayTemp[i] = array[i];
    	}
    	userArray(arrayTemp);
    	long time2 = System.currentTimeMillis();
    	System.out.println("method1 lost time: " + (time2 - time));
    	return time2 - time;
    }

    // 使用System.arraycopy()方法，可以看到他为native方法，性能优越
    static long method2() {
    	long time = System.currentTimeMillis();
    	int[] arrayTemp = new int[array.length];
    	System.arraycopy(array, 0, arrayTemp, 0, array.length);
    	userArray(arrayTemp);
    	long time2 = System.currentTimeMillis();
    	System.out.println("method2 lost time: " + (time2 - time));
    	return time2 - time;
    }
    
    // 使用Arrays.copyOf方法，其内部使用的是System.arraycopy()，效果和上面的差不多
    static long method3() {
    	long time = System.currentTimeMillis();
    	int[] arrayTemp = Arrays.copyOf(array, array.length);
    	userArray(arrayTemp);
    	long time2 = System.currentTimeMillis();
    	System.out.println("method3 lost time: " + (time2 - time));
    	return time2 - time;
    }
    
    // 使用Object.clone()方法，看起来需要强转转换，但实际上性能是最优的。
    static long method4() {
    	long time = System.currentTimeMillis();
    	int[] arrayTemp = array.clone();
    	userArray(arrayTemp);
    	long time2 = System.currentTimeMillis();
    	System.out.println("method4 lost time: " + (time2 - time));
    	return time2 - time;
    }
    
    // 经研究发现，如果数组没有使用它，其复制速度简直超出想象，四个方法全是毫秒级别，只有在使用时才看能出效果
    static void userArray(int[] array) {
    	StringBuilder sb = new StringBuilder();
    	for (int value : array) {
    		sb.append(value + ", ");
    	}
    }
    
}

Eclipse运行结果：

method1 lost time: 25
method2 lost time: 9
method3 lost time: 8
method4 lost time: 8
method1 lost time: 8
method2 lost time: 8
method3 lost time: 6
method4 lost time: 4
method1 lost time: 7
method2 lost time: 4
method3 lost time: 6
method4 lost time: 5
method1 lost time: 6
method2 lost time: 3
method3 lost time: 4
method4 lost time: 4
method1 lost time: 4
method2 lost time: 4
method3 lost time: 4
method4 lost time: 3
time1: 50, time2: 28, time3: 28, time4: 24

经研究发现：

0. 数组在复制后如果没有使用它，其耗时简直是毫秒级别，50000级别的数据，for耗时6毫秒，其他三个耗时1毫秒。故这里在比较时每个方法都使用了一次复制后的数组。

1. For循环方法，性能太慢，在遍历时消耗太多的时间，不推荐该方法。

2. System.arraycopy，该方法为native方法，原生太，性能优越，建议使用。

3. Arrays.copyOf，该方法内部使用的是System.arraycopy，和上面的方法差不多耗时，如果不想写太多的参数，建议使用该方法。

4. Object.clone，该方法另辟蹊径，快速而优越，在遍历它时甚至比原生的native方法还快速，非常推荐使用。

JavaScrpt数组复制方法耗时比较，先上代码：

(function () {
    // 初始化50000个元素的数组
    let array = [];
    for (let i = 0; i < 50000; i ++) {
        array.push(parseInt(10000 * Math.random()));
    }

    method1();
    method2();
    method3();

    // 使用For循环复制数组,效率太低
    function method1() {
        let arrayTemp = [];
        let time = new Date().getTime();
        for (let i = 0; i < array.length; i ++) {
            arrayTemp[i] = array[i];
        }
        userArray(arrayTemp);
        let time2 = new Date().getTime();
        console.log("For lost time: " + (time2 - time));
    }

    // 使用slice复制数组，性能优越，建议使用
    function method2() {
        let time = new Date().getTime();
        let arrayTemp = array.slice();
        userArray(arrayTemp);
        let time2 = new Date().getTime();
        console.log("Slice lost time: " + (time2 - time));
    }

    // 使用concat复制数组，性能极佳，推荐使用
    function method3() {
        let time = new Date().getTime();
        let arrayTemp = array.concat();
        userArray(arrayTemp);
        let time2 = new Date().getTime();
        console.log("Concat lost time: " + (time2 - time));
    }

    // 经研究发现，如果数组没有使用它，其复制速度简直超出想象，三个方法全是0-1毫秒，只有在使用时才看能出效果
    function userArray(array) {
        let sb = "";
        for (let value of array) {
            sb += value + ", "
        }
    }

})();

WebStorm运行结果：

For lost time: 14
Slice lost time: 9
Concat lost time: 3

经研究发现：

0. 数组在复制后如果没有使用它，50000级别的数据，for耗时1毫秒，其他二个耗时0毫秒。故这里在比较时每个方法都使用了一次复制后的数组。

1. For循环方法，性能太慢，在遍历时消耗太多的时间，不推荐该方法。

2. Slice，该方法为仅耗时9个毫秒，性能优越，建议使用。

3. Concat，该方法仅耗时3个毫秒，性能极速，非常推荐使用。

4. JavaScript中数组没有clone方法，使用该方法会报错。