Java基础 数组的拷贝

所谓复制数组,是指将一个数组中的元素在另一个数组中进行复制，下面就一起探讨一下这其中的一些奥妙。

clone

clone方法是从Object类继承过来的，基本数据类型（String ，boolean，char，byte，short，float ，double，long）都可以直接使用clone方法进行克隆，注意String类型是因为其值不可变所以才可以使用。

int[] a1 = {1, 3};
int[] a2 = a1.clone();
System.out.println(Arrays.toString(a2));//[1, 3]

进行clone后可以得到一个新的a2数组打印的结果自然是 1和3 那么通过clone 克隆出来的数组 是否指向克隆数组元素的内存空间呢？ 做个试验

String[] a1 = {"a1", "a2"};
String[] a2 = a1.clone();
a1[0] = "b1"; 
System.out.println(Arrays.toString(a1));   //[b1, a2]
System.out.println(Arrays.toString(a2));   //[a1, a2]

可以看到没有，由此可以得出结论 对于基础类型而言，一维数组是深克隆(重新分配空间,并将元素复制过去)

既然这样！！！那么二维数组呢？？ 于是我瞬间打了个栗子

String[][] a = {{"1", "1", "1", "1", "1"}, {"3", "8"}};
String[][] b = a.clone();
b[1][1] = "9";
System.out.println(b[1][1] + "  " + b[1][1]);// 9  9 

果然在a clone给b的时候 值是引用传递的，由于指向的还是用一块内存，所以改变b中的值 a中的同样也会改变。

由此我们又得出了结论 对于基础类型而言二维数组是浅克隆(只传递引用) 那么问题来了，怎么对基础类型的二维数组进行深克隆呢？

介于一维数组的例子我们不难想象，应该是循环的进行 一维的拷贝。

System.arraycopy

System.arraycopy方法是一个本地的方法，源码里定义如下：

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

属性分别为

(原数组 src ，原数组的开始位置 srcPos，目标数组 dest， 目标数组的开始位置 destPos，拷贝个数 length)

怎么使用呢？ 举个栗子

int[] a1 = {1, 2, 3, 4, 5};
int[] a2 = new int[10];
System.arraycopy(a1, 1, a2, 3, 3);
System.out.println(Arrays.toString(a1)); // [1, 2, 3, 4, 5]
System.out.println(Arrays.toString(a2)); // [0, 0, 0, 2, 3, 4, 0, 0, 0, 0]

意思就是 原数组 a1 从第一个开始，copy到 a2 ，从a2 的3下标开始，拷贝3个。当使用这个方法的时候，需要复制到一个已经分配内存单元的数组。

Arrays.copyOf

Arrays.copyOf底层其实也是用的System.arraycopy 源码如下：

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;
    }

属性分别为

(原数组 original，拷贝的个数 newLength)

怎么使用呢？举个栗子

int[] a1 = {1, 2, 3, 4, 5};
int[] a2 = Arrays.copyOf(a1, 3);
System.out.println(Arrays.toString(a1));// [1, 2, 3, 4, 5]
System.out.println(Arrays.toString(a2));// [1, 2, 3]

使用该方法无需我们事先使用new关键字对对象进行内存单元的分配

这方法，是不是很爽，配合System.arraycopy 不难做出数组的动态扩容

String[] as = {};
for (int i = 0; i < 5; i++) {
    String[] b = {String.valueOf(i), String.valueOf(i)};
    as = Arrays.copyOf(as, as.length + b.length);//数组扩容
    System.arraycopy(b, 0, as, as.length-b.length, b.length);
}
System.out.println(Arrays.toString(as));//[0, 0, 1, 1, 2, 2, 3, 3, 4, 4]

Arrays.copyOfRange

Arrays.copyOfRange底层其实也是用的System.arraycopy，只不过封装了一个方法

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);
    @SuppressWarnings("unchecked")
    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;
}

属性分别为

（原数组 original，开始位置 from，拷贝的个数 to）

依然是栗子

int[] a1 = {1, 2, 3, 4, 5};
int[] a2 = Arrays.copyOfRange(a1, 0, 1);
System.out.println(Arrays.toString(a1)) // [1, 2, 3, 4, 5]
System.out.println(Arrays.toString(a2)) // [1]

最后需要注意的是 最后需要注意的是基本类型的拷贝是不影响原数组的值的。如果是引用类型，就不能在这用了，对于引用类型是不适合的。

那么如何给一个对象进行深度拷贝呢？

实现Cloneable接口

实现Cloneable接口，并重写clone方法，注意一个类不实现这个接口，直接使用clone方法是编译通不过的。

class Mao implements Cloneable {
    private String miao;
    private String wang;
    //.....get  set  toString 
    @Override
    public Mao clone() throws CloneNotSupportedException {
        return (Mao) super.clone();
    }
}

然后就可以玩啦

Mao m1 = new Mao("miao", "wang");
Mao m2 = dog1.clone();
m2.setWang("miao");
System.out.println(m1); // Mao{id='miao', name='miao'}
System.out.println(m2); // Mao{id='miao', name='miao'}

组合类深拷贝

如果一个类里面，又引用其他的类，其他的类又有引用别的类，那么想要深度拷贝必须所有的类及其引用的类都得实现Cloneable接口，重写clone方法，这样以来非常麻烦，简单的方法是让所有的对象实现序列化接口（Serializable），然后通过序列化反序列化的方法来深度拷贝对象。

public Mao myClone() {
    Mao m = null;
    try {
        //将对象序列化成为流，因为写在流是对象里的一个拷贝
        //而原始对象扔在存在JVM中，所以利用这个特性可以实现深拷贝
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(this);
        //将流序列化为对象
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        m = (Mao) objectInputStream.readObject();
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
    return m;
}

总结

注意除非必需，一般情况下不要使用对象的深度拷贝，因为性能较差，况且这方面的知识单纯的在工作中也不太可能会注意到，除了自己实现深度拷贝的功能外，lang3 是个神器的玩意，但原理都大同小异，感兴趣的同学可以自己去学习下。