克隆和序列化應用

克隆

在開始學習克隆以前，咱們先來看看下面的代碼，普通的對象複製，存在什麼問題？java

class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        // 等號賦值（ 基本類型）
        int number = 6;
        int number2 = number;
        // 修改 number2 的值
        number2 = 9;
        System.out.println("number：" + number);
        System.out.println("number2：" + number2);
        // 等號賦值（對象）
        Dog dog = new Dog();
        dog.name = "旺財";
        dog.age = 5;
        Dog dog2 = dog;
        // 修改 dog2 的值
        dog2.name = "大黃";
        dog2.age = 3;
        System.out.println(dog.name + "，" + dog.age + "歲");
        System.out.println(dog2.name + "，" + dog2.age + "歲");
    }
}

程序執行結果：面試

number：6
number2：9
大黃，3歲
大黃，3歲

能夠看出，若是使用等號複製時，對於值類型來講，彼此之間的修改操做是相對獨立的，而對於引用類型來講，由於複製的是引用對象的內存地址，因此修改其中一個值，另外一個值也會跟着變化，原理以下圖所示：網絡

所以爲了防止這種問題的發生，就要使用對象克隆來解決引用類型複製的問題。ide

1）淺克隆

默認的 clone() 方法，爲淺克隆，代碼以下：工具

class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Dog dog = new Dog();
        dog.name = "旺財";
        dog.age = 5;
        // 克隆
        Dog dog3 = (Dog) dog.clone();
        dog3.name = "小白";
        dog3.age = 2;
        System.out.println(dog.name + "，" + dog.age + "歲");
        System.out.println(dog3.name + "，" + dog3.age + "歲");
    }
}
class Dog implements Cloneable {
    public String name;
    public int age;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

程序執行結果：學習

旺財，5歲
小白，2歲

能夠看出使用克隆就能夠解決引用類型複製的問題了，原理以下圖所示：開發工具

以上這種複製方式叫作淺克隆。this

淺克隆的實現條件：須要克隆的對象必須實現 Cloneable 接口，並重寫 clone() 方法，便可實現對此對象的克隆。3d

然而使用淺克隆也會存在一個問題，請參考如下代碼。code

class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        DogChild dogChild = new DogChild();
        dogChild.name = "二狗";
        Dog dog4 = new Dog();
        dog4.name = "大黃";
        dog4.dogChild = dogChild;
        Dog dog5 = (Dog) dog4.clone();
        dog5.name = "旺財";
        dog5.dogChild.name = "狗二";
        System.out.println("dog name 4："+dog4.name);
        System.out.println("dog name 5："+dog5.name);
        System.out.println("dog child name 4："+dog4.dogChild.name);
        System.out.println("dog child name 5："+dog5.dogChild.name);
    }
}
class Dog implements Cloneable {
    public String name;
    public DogChild dogChild;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class DogChild {
    public String name;
}

程序執行結果：

dog name 4：大黃
dog name 5：旺財
dog child name 4：狗二
dog child name 5：狗二

也就是說淺克隆，只會複製對象的值類型，而不會複製對象的引用類型。緣由以下圖所示：

要處理引用類型不被複制的問題，就要使用到深克隆。

2）深克隆

定義：深克隆就是複製整個對象信息，包含值類型和引用類型。

深克隆的實現方式一般包含如下兩種。

序列化實現深克隆：先將原對象序列化到內存的字節流中，再從字節流中反序列化出剛剛存儲的對象，這個新對象和原對象就不存在任何地址上的共享，這樣就實現了深克隆。
全部引用類型都實現克隆：要複製對象的全部引用類型都要實現克隆，全部對象都是複製的新對象，從而實現了深克隆。

深克隆實現方式一：序列化

實現思路：先將要拷貝對象寫入到內存中的字節流中，而後再從這個字節流中讀出剛剛存儲的信息，做爲一個新對象返回，那麼這個新對象和原對象就不存在任何地址上的共享，天然實現了深拷貝。請參考如下代碼：

class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        BirdChild birdChild = new BirdChild();
        birdChild.name = "小小鳥";
        Bird bird = new Bird();
        bird.name = "小鳥";
        bird.birdChild = birdChild;
        // 使用序列化克隆對象
        Bird bird2 = CloneUtils.clone(bird);
        bird2.name = "黃雀";
        bird2.birdChild.name = "小黃雀";
        System.out.println("bird name:" + bird.name);
        System.out.println("bird child name:" + bird.birdChild.name);
        System.out.println("bird name 2:" + bird2.name);
        System.out.println("bird child name 2:" + bird2.birdChild.name);
    }
}
class CloneUtils {
    public static <T extends Serializable> T clone(T obj) {
        T cloneObj = null;
        try {
            //寫入字節流
            ByteArrayOutputStream bo = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bo);
            oos.writeObject(obj);
            oos.close();
            //分配內存,寫入原始對象,生成新對象
            ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());//獲取上面的輸出字節流
            ObjectInputStream oi = new ObjectInputStream(bi);
            //返回生成的新對象
            cloneObj = (T) oi.readObject();
            oi.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cloneObj;
    }
}

程序執行結果：

bird name:小鳥
bird child name:小小鳥
bird name 2:黃雀
bird child name 2:小黃雀

深克隆實現方式二：全部引用類型都實現克隆

class SerializableTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
    ParrotChild parrotChild = new ParrotChild();
        parrotChild.name = "小鸚鵡";
        Parrot parrot = new Parrot();
        parrot.name = "大鸚鵡";
        parrot.parrotChild = parrotChild;
        // 克隆
        Parrot parrot2 = (Parrot) parrot.clone();
        parrot2.name = "老鸚鵡";
        parrot2.parrotChild.name = "少鸚鵡";
        System.out.println("parrot name:" + parrot.name);
        System.out.println("parrot child name:" + parrot.parrotChild.name);
        System.out.println("parrot name 2:" + parrot2.name);
        System.out.println("parrot child name 2:" + parrot2.parrotChild.name);
    }
 }
class Parrot implements Cloneable {
    public String name;
    public ParrotChild parrotChild;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Parrot bird = (Parrot) super.clone();
        bird.parrotChild = (ParrotChild) parrotChild.clone();
        return bird;
    }
}
class ParrotChild implements Cloneable {
    public String name;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

程序執行結果：

parrot name:大鸚鵡
parrot child name:小鸚鵡
parrot name 2:老鸚鵡
parrot child name 2:少鸚鵡

序列化和反序列化

1）介紹

內存中的數據對象只有轉換成二進制流才能進行數據持久化或者網絡傳輸，將對象轉換成二進制流的過程叫作序列化（Serialization）；相反，把二進制流恢復爲數據對象的過程就稱之爲反序列化（Deserialization）。

2）序列化和反序列代碼實現

先把對象序列化到磁盤，再從磁盤中反序列化出對象，請參考如下代碼：

class SerializableTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 對象賦值
        User user = new User();
        user.setName("老王");
        user.setAge(30);
        System.out.println(user);
        // 建立輸出流（序列化內容到磁盤）
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test.out"));
        // 序列化對象
        oos.writeObject(user);
        oos.flush();
        oos.close();
        // 建立輸入流（從磁盤反序列化）
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.out"));
        // 反序列化
        User user2 = (User) ois.readObject();
        ois.close();
        System.out.println(user2);
    }
}
class User implements Serializable {
    private static final long serialVersionUID = 3831264392873197003L;
    private String name;
    private int age;
    @Override
    public String toString() {
        return "{name:" + name + ",age:" + age + "}";
    }
    // setter/getter...
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

程序執行結果：

{name:老王,age:30}
{name:老王,age:30}

更多序列化和反序列化的實現方式以及代碼示例，請看下文面試部分的內容。

開發工具設置：IDEA 開啓自動生成 serialVersionUID 點擊 Settings → Inspections → 搜索 Serialization issues → 勾選 Serializable class without 'SerialVersionUID' 保存設置，以下圖所示：

設置完以後，光標放到類名上，點擊提示，生成 serialVersionUID，以下圖所示：