java基础-深、浅克隆

1.Cloneable 接口

空的接口，用于标记，让 JVM 知道这个类具有浅克隆功能。如果不实现此接口，在调用 clone() 方法时会抛出 CloneNotSupportException。

1.1JVM 实现浅克隆

创建一个新的对象，将原对象内容复制到新的对象中。不需要初始化字段，因为都是从原对象中拷贝过来的，也就不需要调用实例化构造方法。

1.2浅克隆

只是将对象的内容拷贝一份给新对象。对象的内容分为1.基本类型数据 2.引用类型数据

拷贝基本类型数据就是拷贝值而已，很简单。

拷贝引用类型数据也只是拷贝对象引用而已。单纯的拷贝导致克隆后的两个对象中的引用类型数据指向堆中同一个地址。

浅克隆
public class CloneTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("thd");
        ArrayList<Person> personArrayList1 = new ArrayList<>();
        personArrayList1.add(person);
        ArrayList<Person> personArrayList2 = ( ArrayList<Person> ) personArrayList1.clone();
        personArrayList2.get(0).setName("djw");


        System.out.println(personArrayList1.get(0).getName()); //“djw"

    }
    

当克隆对象修改引用类型成员时，原对象的内容也随之更改。这是不太符合预期的，克隆体应当是一个新的个体，与被克隆体再无瓜葛。深克隆可以避免这种情况的发生。

2.Serializable 接口

空的接口，用于标记，让 JVM 知道这个类具有深克隆功能。实现此接口后，可以被序列化。

2.1深克隆

不光将对象中的基本类型数据拷贝；还将对象中的引用类型数据一起深克隆(需要实现Serializable接口)。深克隆后的克隆体与被克隆体毫无瓜葛，克隆体随意修改数据都不会对被克隆体造成影响。

public static void main(String[] args) {
    Person person = new Person();
    person.setName("thd");
    ArrayList<Person> personArrayList1 = new ArrayList<>();
    personArrayList1.add(person);
    ArrayList<Person> personArrayList2 = ( ArrayList<Person> ) personArrayList1.clone();
    personArrayList2.get(0).setName("djw");


    System.out.println(personArrayList1.get(0).getName());//"djw"

    ArrayList<Person> personArrayList3 = deepClone(personArrayList1);
    if (personArrayList3 != null){
        personArrayList3.get(0).setName("123");
        System.out.println(personArrayList1.get(0).getName());//"djw"
    }


}

public static ArrayList<Person> deepClone(ArrayList<Person> list){
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    ObjectOutputStream objectOutputStream = null;
    ByteArrayInputStream byteArrayInputStream = null;
    ObjectInputStream objectInputStream = null;
    try {
        objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(list);

        byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        objectInputStream = new ObjectInputStream(byteArrayInputStream);
        ArrayList<Person> object = (ArrayList<Person>) objectInputStream.readObject();
        return object;
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }finally {
        try {
            byteArrayInputStream.close();
            byteArrayOutputStream.flush();
            byteArrayOutputStream.close();
            objectOutputStream.flush();
            objectOutputStream.close();
            objectInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return null;
}

2.2自动/自定义序列化

当通过 ObjectInput/OutputStream 反序列化/序列化 对象时，JVM 通过反射调用类中重写的 readObject()，writeObject() 方法实现自定义序列化；如果没有则调用 ObjectInput/OutputStream 的 defaultReadObject() 、defaultWriteObject()，实现自动序列化；

transient 关键字可以修饰成员变量，用于标识该成员变量不能被序列化。对象被序列化后，该成员变量为默认空值。

2.3ArrayList 自定义序列化源码：

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

ArrayList 的 elementData[] 成员用于储存数据，被 transient 修饰。目的就是 ArrayList 想自己控制数组的序列化过程。wreteObject() 方法中首先调用 ObjectOutputStream:: defaultWriteObject()将类中可自动序列化部分完成序列化。剩余的代码就是对 elementData 进行特殊操作，去除无效元素。

for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
   }

if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
   }

乍一看，也看不出来 ArrayList 做出了什么特殊操作。仔细看，for 循环的结束条件是 i < size。

在 ArrayList 中有两个属性 1.size 2.length

size 是指 elementData[] 的真实大小，存储了多少个元素

length是指 elementData[] 的容量，能存储多少个元素

因为 ArrayList 是动态数组，能够动态扩容(每次扩容至1.5倍)。但扩容以后，数组中很可能会存在多个空位等待新元素的插入。如果此时进行自动序列化，那么将序列化多个空元素，很浪费系统资源。为了避免浪费，ArrayList 重写 writeObject 实现自定义序列化，目的是只序列化 elementData 中实际存在的元素。

2.4serialVersionUID

当我们对数据进行反序列化时，需要判断两个类的 serialVersionUID 是否一致。如果不一致，则表示实体类不是同一个版本，代码不同，不能进行反序列化。