数组的复制，数组复制的三种方式

一、数组复制的三种方式

String[] a = {"1", "2", "3", "4", "5"};

// 方法一
// Arrays.copyOf()
String[] b = Arrays.copyOf(a, a.length);
System.out.println("Arrays.copyOf(): " + Arrays.toString(b));

// 方法二
// Object.clone()
String[] c = a.clone();
System.out.println("Object.clone(): " + Arrays.toString(c));

// 方法三
// System.arraycopy()
String[] s = new String[a.length];
System.arraycopy(a, 0, s, 0, a.length);
System.out.println("System.arraycopy(): " + Arrays.toString(s));

解释：

方法一：使用 Array.copyof()

       源码解读：方法需要两个参数 ，1）original ： 要被复制的目标数组。  2）newLength：新数组的长度，意思就是，可以复制目标数组的0～original.length 部分。 

方法二： 使用 Object.clone()

       要求被复制的对象实现Cloneable（implements Cloneable ）才可以复制，否则会抛出CloneNotSupportedException 异常，好在Java中数组实现了Cloneable ，但是Map和List是没有实现的。

方法三： 使用 System.arraycopy()， 看一下jdk1.8的api

/**
     * Copies an array from the specified source array, beginning at the
     * specified position, to the specified position of the destination array.
     * A subsequence of array components are copied from the source
     * array referenced by src to the destination array
     * referenced by dest. The number of components copied is
     * equal to the length argument. The components at
     * positions srcPos through
     * srcPos+length-1 in the source array are copied into
     * positions destPos through
     * destPos+length-1, respectively, of the destination
     * array.
     * 

     * If the src and dest arguments refer to the
     * same array object, then the copying is performed as if the
     * components at positions srcPos through
     * srcPos+length-1 were first copied to a temporary
     * array with length components and then the contents of
     * the temporary array were copied into positions
     * destPos through destPos+length-1 of the
     * destination array.
     * 

     * If dest is null, then a
     * NullPointerException is thrown.
     * 

     * If src is null, then a
     * NullPointerException is thrown and the destination
     * array is not modified.
     * 

     * Otherwise, if any of the following is true, an
     * ArrayStoreException is thrown and the destination is
     * not modified:
     * 

     * 
The src argument refers to an object that is not an
     *     array.
     * 
The dest argument refers to an object that is not an
     *     array.
     * 
The src argument and dest argument refer
     *     to arrays whose component types are different primitive types.
     * 
The src argument refers to an array with a primitive
     *    component type and the dest argument refers to an array
     *     with a reference component type.
     * 
The src argument refers to an array with a reference
     *    component type and the dest argument refers to an array
     *     with a primitive component type.
     * 
     * 

     * Otherwise, if any of the following is true, an
     * IndexOutOfBoundsException is
     * thrown and the destination is not modified:
     * 

     * 
The srcPos argument is negative.
     * 
The destPos argument is negative.
     * 
The length argument is negative.
     * 
srcPos+length is greater than
     *     src.length, the length of the source array.
     * 
destPos+length is greater than
     *     dest.length, the length of the destination array.
     * 
     * 

     * Otherwise, if any actual component of the source array from
     * position srcPos through
     * srcPos+length-1 cannot be converted to the component
     * type of the destination array by assignment conversion, an
     * ArrayStoreException is thrown. In this case, let
     * k be the smallest nonnegative integer less than
     * length such that src[srcPos+k]
     * cannot be converted to the component type of the destination
     * array; when the exception is thrown, source array components from
     * positions srcPos through
     * srcPos+k-1
     * will already have been copied to destination array positions
     * destPos through
     * destPos+k-1 and no other
     * positions of the destination array will have been modified.
     * (Because of the restrictions already itemized, this
     * paragraph effectively applies only to the situation where both
     * arrays have component types that are reference types.)
     *
     * @param      src      the source array.
     * @param      srcPos   starting position in the source array.
     * @param      dest     the destination array.
     * @param      destPos  starting position in the destination data.
     * @param      length   the number of array elements to be copied.
     * @exception  IndexOutOfBoundsException  if copying would cause
     *               access of data outside array bounds.
     * @exception  ArrayStoreException  if an element in the src
     *               array could not be stored into the dest array
     *               because of a type mismatch.
     * @exception  NullPointerException if either src or
     *               dest is null.
     */
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

注释就不解释了，说一下参数：

*@param src源数组。

*源数组中的@param srcPos起始位置。

*@param dest目标数组。

*@param destPos目标数据中的起始位置。

*@param length要复制的数组元素数。

扩展：

问：这三种方法，哪个最佳呢？

搭：建议使用 System.arraycopy(), 仔细看api你会发现 Arrays.copyof() 里面又调用了 copyof() 方法，进入copyof你会发现 用的还是System.arraycopy()