【JAVA】数组复制效率的比较

                                          数组复制效率的比较

java中数组复制的方式，有以下几种

（1）System.arraycopy（）；

（2）Arrays.copyOf（）；

（3）clone（）；

（4）for循环

今天我们比较一下这四者的效率

---

一、System.arraycopy（）

此方法的源码如下：

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

可见此方法是一个本地方法，方法对应的实现不在当前文件里，而是在其他语言实现的的文件的，比如C、C++中。

使用本地方法，案例来说效率应该最高，稍后进行效率测试。

---

二、Arrays.copyOf（）

此方法的源码如下：

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

可以看得出来，本质上调用的是System.arraycopy（）方法，也就是前一种方法，那么效率肯定比不上前一种数组复制方法。

---

三、clone（）

此方法的源码如下：

 protected native Object clone() throws CloneNotSupportedException;

这个方法是Object类中的一个本地方法，这里虽然返回Object，看着需要强制类型转换，但Object子类重写了这个方法，会返回相应的类型。

---

四、for循环

最简单粗暴的一种方式，循环原始数组并直接赋值到目标数组中。

---

五、四种的比较

他们之间的效率比较需要从原始数组的大小出发。

先贴出比较的代码：

package day0908;

import java.util.Arrays;

public class TestArrayCopy {
    public static void testSystemArrayCopy(String[] orginal) {
        long start_time = System.nanoTime();
        String[] target = new String[orginal.length];
        System.arraycopy(orginal, 0, target, 0, target.length);
        long end_time = System.nanoTime();
        System.out.println("使用System.arraycopy方法耗时:" + (end_time - start_time));

    }

    public static void testArraysCopyOf(String[] orginal) {
        long start_time = System.nanoTime();
        String[] target = new String[orginal.length];
        target = Arrays.copyOf(orginal, orginal.length);
        long end_time = System.nanoTime();
        System.out.println("使用Arrays.copyOf方法耗时:" + (end_time - start_time));
    }

    public static void testClone(String[] orginal) {
        long start_time = System.nanoTime();
        String[] target = new String[orginal.length];
        target = orginal.clone();
        long end_time = System.nanoTime();
        System.out.println("使用clone方法耗时:" + (end_time - start_time));
    }

    public static void testFor(String[] orginal) {
        long start_time = System.nanoTime();
        String[] target = new String[orginal.length];
        for (int i = 0; i < orginal.length; i++) {
            target[i] = orginal[i];
        }
        long end_time = System.nanoTime();
        System.out.println("使用for循环耗时:" + (end_time - start_time));
    }

    public static void main(String args[]) {
        //需要改变原始数组的大小
        String[] original = new String[100];
        for (int i = 0; i < original.length; i++) {
            original[i] = "abcd";
        }
        System.out.println("原始数组的大小:" + original.length);
        testSystemArrayCopy(original);
        testArraysCopyOf(original);
        testClone(original);
        testFor(original);
    }
}

比较他们之间的效率需要从目标数组的大小出发。

【1】目标数组是个小数组，长度在200以内

四种方式的效率：

可以看得出：Arrays.copyOf（）的效率最差，其余三种效率差异不大。

---

【2】目标是个中等数组，长度以千为单位。

四种方式的效率：

可以看得出，System.arraycopy（）与clone（）方式差异不大，使用for循环的方式，耗时比之前的情况变得严重起来。

---

【3】目标数组是个大型数组，长度以万为单位。

四种方式的效率：

可以看得出，此时System.arraycopy（）方法的效率最高，且数组长度在此基础增加时，此方法效率还是最高，而for循环的效率在这种情况下表现得十分糟糕。

---

六、总结

（1）原始数组长度不管是多少的时候，Arrays.copyOf（）的效率都比System.arraycopy（）差。

（2）原始数组长度比较小的时候，几百以内，for循环表现十分优异，并随着数组长度的增加，效率越来越低，因此，for循环适合于小型数组。

（3）原始数组长度中等的时候，比如几千的时候，两个本地方法的效率差不多。

（4）原始数组长度比较大的时候，以万为单位，这时候本地方法System.arraycopy（）方法的优势体现出来了，力压其他三种方式。

因此，需要根据操作的数组的长度，灵活地选择数组复制方式，会使得我们的程序得到性能的略微提升。