java杂记——数组拷贝

这里介绍两种java提供的数组拷贝方法：

（1）Arrays提供的copyOf(T src, T desLength)和copyOfRange(T src, int from, int to)

（2）System.arraycopy(T src, int from, T des, int from, int length)

 使用例子：

（1）

int [] a = {1,2,3,4,5,6};
int [] b = Arrays.copyOf(a, 8); //把a拷贝到长度为8的b中。b的长度可比a长，长的部分补0；可比a短，把a截断。
int [] c = Arrays.copyOfRange(a, 2, 5); //把a的数组下标为2的到下标为5的前一个，拷贝到c中，c的长度为5-2=3。

（2）

int [] a = {1,2,3,4,5,6};
int [] b = new int[8];
System.arraycopy(a, 2, b, 3, 4); //把数组a从下标为2的元素开始，拷贝长度为4的元素到b中，从b的下标为3的位置开始放。
　　　　　　　　　　　　　　　　//如果b的位置不足以放下指定长度的元素，会报java.lang.ArrayIndexOutOfBoundsException异常

 

在方法（2）中，如果目标数组和源数组相同，则先拷贝到一个temp数组中，再从temp数组中拷回目标数组（源）。

 

当数组是对象数组的时候，上面的两种方法都不能实现深度拷贝。例如：源代码中的

Lesson9_arrayCopyTest.deepArrayCopy()

 

详细代码如下：

package javaBase16Lesson;



import java.util.Arrays;



/**

 * （1）

 *     int [] a = {1,2,3,4,5,6};

 *    int [] b = Arrays.copyOf(a, 8);    //把a拷贝到长度为8的b中。b的长度可比a长，长的部分补0；可比a短，把a截断。

 *    int [] c = Arrays.copyOfRange(a, 2, 5);  //把a的数组下标为2的到下标为5的前一个，拷贝到c中，c的长度为5-2=3。

 *

 *（2）

 *    int [] a = {1,2,3,4,5,6};

 *    int [] b = new int[8];

 *    System.arraycopy(a, 2, b, 3, 4);  //把数组a从下标为2的元素开始，拷贝长度为4的元素到b中，从b的下标为3的位置开始放。

 *                                                     //如果b的位置不足以放下指定长度的元素，会报java.lang.ArrayIndexOutOfBoundsException异常

 *

 *（3）

 *方法（1）（2）都只是数组的浅拷贝，无法实现深度拷贝

 * @author cnx

 * @Description : arrayCopyTest

 * @CreateDate ; 2014年7月9日 下午6:43:26

 */

public class Lesson9_arrayCopyTest {

    public static void main(String[] args) {

//        Lesson9_arrayCopyTest.arraysCopyOf();

//        Lesson9_arrayCopyTest.systemArraycopy();

        Lesson9_arrayCopyTest.deepArrayCopy();

    }

    

    

    public static void arraysCopyOf(){

        int [] a = {1,2,3,4,5,6};

        int [] b = Arrays.copyOf(a, 8);    //把a拷贝到长度为8的b中。b的长度可比a长，长的部分补0；可比a短，把a截断。

        int [] c = Arrays.copyOfRange(a, 2, 5);  //把a的数组下标为2的到下标为5的前一个，拷贝到c中，c的长度为5-2=3。

        System.out.println("a:"+ a.length);

        for (int i = 0; i < a.length; i++) {

            System.out.println(a[i]);

        }

        System.out.println("b:"+ b.length);

        for (int i : b) {

            System.out.println(i);

        }

        System.out.println("c:"+ c.length);

        for (int i : c) {

            System.out.println(i);

        }

    }

    /**

     *         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. <br>

     * 如果目标数组和源数组相同，则先拷贝到一个temp数组中，再从temp数组中拷回目标数组（源）

     */

    public static void systemArraycopy(){

        int [] a = {1,2,3,4,5,6};

        int [] b = new int[8];

        System.arraycopy(a, 2, b, 3, 4);  //把数组a从下标为2的元素开始，拷贝长度为4的元素到b中，从b的下标为3的位置开始放。

                                                         //如果b的位置不足以放下指定长度的元素，会报java.lang.ArrayIndexOutOfBoundsException异常

        System.out.println("a:"+ a.length);

        for (int i = 0; i < a.length; i++) {

            System.out.println(a[i]);

        }

        System.out.println("b:"+ b.length);

        for (int i : b) {

            System.out.println(i);

        }

    }

    

    /**

     * 上面的两种方法都无法实现深度拷贝

     */

    public static void deepArrayCopy(){

        Lesson9_array1 [] a1 = {new Lesson9_array1(),new Lesson9_array1()}; 

        Lesson9_array1 [] a2 = null;

        Lesson9_array1 [] a3 = new Lesson9_array1[3];

        Lesson9_array2 [] b1 = {new Lesson9_array2(),new Lesson9_array2()}; 

        Lesson9_array2 [] b2 = null;

        

        

        a2 = Arrays.copyOf(a1, 3);

        System.arraycopy(a1, 0, a3, 0, 2);

        b2 = Arrays.copyOf(b1, 3);

        

        a1[1].a = "a1";

        System.out.println(a2[1].a);

        System.out.println(a3[1].a);

        b1[1].a = "b1";

        System.out.println(b2[1].a);

    }

}





class Lesson9_array1 implements Cloneable{

    public String a = "deep";

    

    public Object clone(){

        Object o = null;

        try {

            o = (Lesson9_array1)super.clone();

        } catch (CloneNotSupportedException e) {

            e.printStackTrace();

        }

        return o;

    }

    

    public String toString(){

        return a;

    }

}



class Lesson9_array2{

    public String a = "deep";

    

    public String toString(){

        return a;

    }

}