摘要：對象序列化對象序列化機(jī)制允許把內(nèi)存中的對象轉(zhuǎn)換成與平臺無關(guān)的二進(jìn)制流，從而可以保存到磁盤或者進(jìn)行網(wǎng)絡(luò)傳輸，其它程序獲得這個二進(jìn)制流后可以將其恢復(fù)成原來的對象。

對象序列化機(jī)制允許把內(nèi)存中的Java對象轉(zhuǎn)換成與平臺無關(guān)的二進(jìn)制流，從而可以保存到磁盤或者進(jìn)行網(wǎng)絡(luò)傳輸，其它程序獲得這個二進(jìn)制流后可以將其恢復(fù)成原來的Java對象。 序列化機(jī)制可以使對象可以脫離程序的運行而對立存在

序列化機(jī)制可以使對象可以脫離程序的運行而對立存在

序列化（Serialize）指將一個java對象寫入IO流中，與此對應(yīng)的是，對象的反序列化（Deserialize）則指從IO流中恢復(fù)該java對象

如果需要讓某個對象可以支持序列化機(jī)制，必須讓它的類是可序列化（serializable），為了讓某個類可序列化的，必須實現(xiàn)如下兩個接口之一：

Serializable：標(biāo)記接口，實現(xiàn)該接口無須實現(xiàn)任何方法，只是表明該類的實例是可序列化的

Externalizable

所有在網(wǎng)絡(luò)上傳輸?shù)膶ο蠖紤?yīng)該是可序列化的，否則將會出現(xiàn)異常；所有需要保存到磁盤里的對象的類都必須可序列化；程序創(chuàng)建的每個JavaBean類都實現(xiàn)Serializable；

實現(xiàn)Serializable實現(xiàn)序列化的類，程序可以通過如下兩個步驟來序列化該對象：

1.創(chuàng)建一個ObjectOutputStream，這個輸出流是一個處理流，所以必須建立在其他節(jié)點流的基礎(chǔ)之上

// 創(chuàng)建個ObjectOutputStream輸出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));

2.調(diào)用ObjectOutputStream對象的writeObject方法輸出可序列化對象

// 將一個Person對象輸出到輸出流中
oos.writeObject(per);

定義一個NbaPlayer類，實現(xiàn)Serializable接口，該接口標(biāo)識該類的對象是可序列化的

public class NbaPlayer implements java.io.Serializable
{
    private String name;
    private int number;
    // 注意此處沒有提供無參數(shù)的構(gòu)造器!
    public NbaPlayer(String name, int number)
    {
        System.out.println("有參數(shù)的構(gòu)造器");
        this.name = name;
        this.number = number;
    }

    // name的setter和getter方法
    public void setName(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return this.name;
    }

    // number的setter和getter方法
    public void setNumber(int number)
    {
        this.number = number;
    }
    public int getNumber()
    {
        return this.number;
    }
}

使用ObjectOutputStream將一個NbaPlayer對象寫入磁盤文件

import java.io.*;

public class WriteObject
{
    public static void main(String[] args)
    {
        try(
            // 創(chuàng)建一個ObjectOutputStream輸出流
            ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("object.txt")))
        {
            NbaPlayer player = new NbaPlayer("維斯布魯克", 0);
            // 將player對象寫入輸出流
            oos.writeObject(player);
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
    }
}

從二進(jìn)制流中恢復(fù)Java對象，則需要使用反序列化，程序可以通過如下兩個步驟來序列化該對象：

1.創(chuàng)建一個ObjectInputStream輸入流，這個輸入流是一個處理流，所以必須建立在其他節(jié)點流的基礎(chǔ)之上

// 創(chuàng)建個ObjectInputStream輸入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt")); 

2.調(diào)用ObjectInputStream對象的readObject()方法讀取流中的對象，該方法返回一個Object類型的Java對象，可進(jìn)行強(qiáng)制類型轉(zhuǎn)換成其真實的類型

// 從輸入流中讀取一個Java對象，并將其強(qiáng)制類型轉(zhuǎn)換為Person類
Person p = (Person)ois.readObject();

從object.txt文件中讀取NbaPlayer對象的步驟

import java.io.*;
public class ReadObject
{
    public static void main(String[] args)
    {
        try(
            // 創(chuàng)建一個ObjectInputStream輸入流
            ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("object.txt")))
        {
            // 從輸入流中讀取一個Java對象，并將其強(qiáng)制類型轉(zhuǎn)換為NbaPlayer類
            NbaPlayer player = (NbaPlayer)ois.readObject();
            System.out.println("名字為：" + player.getName()
                + "
號碼為：" + player.getNumber());
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

反序列化讀取的僅僅是Java對象的數(shù)據(jù)，而不是Java類，因此采用反序列化恢復(fù)Java對象時，必須提供Java對象所屬的class文件，否則會引發(fā)ClassNotFoundException異常；反序列化機(jī)制無須通過構(gòu)造器來初始化Java對象

如果使用序列化機(jī)制向文件中寫入了多個Java對象，使用反序列化機(jī)制恢復(fù)對象必須按照實際寫入的順序讀取。當(dāng)一個可序列化類有多個父類時（包括直接父類和間接父類），這些父類要么有無參的構(gòu)造器，要么也是可序列化的—否則反序列化將拋出InvalidClassException異常。如果父類是不可序列化的，只是帶有無參數(shù)的構(gòu)造器，則該父類定義的Field值不會被序列化到二進(jìn)制流中

如果某個類的Field類型不是基本類型或者String類型，而是另一個引用類型，那么這個引用類型必須是可序列化的，否則有用該類型的Field的類也是不可序列化的

public class AllStar implements java.io.Serializable
{
    private String name;
    private NbaPlayer player;
    public AllStar(String name, NbaPlayer player)
    {
        this.name = name;
        this.player = player;
    }

    // name的setter和getter方法
    public String getName()
    {
        return this.name;
    }

    public void setName(String name)
    {
        this.name = name;
    }
    

    // player的setter和getter方法
    public NbaPlayer getPlayer() 
    {
        return player;
    }
    
    public void setPlayer(NbaPlayer player) 
    {
        this.player = player;
    }
}

所有保存到磁盤中的對象都有一個序列化編號

當(dāng)程序試圖序列化一個對象時，程序?qū)⑾葯z查該對象是否已經(jīng)被序列化過，只有該對象從未（在本次虛擬中機(jī)）被序列化過，系統(tǒng)才會將該對象轉(zhuǎn)換成字節(jié)序列并輸出

如果某個對象已經(jīng)序列化過，程序?qū)⒅皇侵苯虞敵鲆粋€序列化編號，而不是再次重新序列化該對象

import java.io.*;
public class WriteAllStar
{
    public static void main(String[] args)
    {
        try(
            // 創(chuàng)建一個ObjectOutputStream輸出流
            ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("allStar.txt")))
        {
            NbaPlayer player = new NbaPlayer("詹姆斯哈登", 13);
            AllStar allStar1 = new AllStar("西部全明星", player);
            AllStar allStar2 = new AllStar("首發(fā)后衛(wèi)", player);
            // 依次將四個對象寫入輸出流
            oos.writeObject(allStar1);
            oos.writeObject(allStar2);
            oos.writeObject(player);
            oos.writeObject(allStar2);
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
    }
}

4個寫入輸出流的對象，實際上只序列化了3個，而且序列的兩個AllStar對象的player引用實際是同一個NbaPlayer對象。以下程序讀取序列化文件中的對象

import java.io.*;
public class ReadAllStar
{
    public static void main(String[] args)
    {
        try(
            // 創(chuàng)建一個ObjectInputStream輸出流
            ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("allStar.txt")))
        {
            // 依次讀取ObjectInputStream輸入流中的四個對象
            AllStar star1 = (AllStar)ois.readObject();
            AllStar star2 = (AllStar)ois.readObject();
            NbaPlayer player = (NbaPlayer)ois.readObject();
            AllStar star3 = (AllStar)ois.readObject();
            // 輸出true
            System.out.println("star1的player引用和player是否相同："
                + (star1.getPlayer() == player));
            // 輸出true
            System.out.println("star2的player引用和player是否相同："
                + (star2.getPlayer() == player));
            // 輸出true
            System.out.println("star2和star3是否是同一個對象："
                + (star2 == star3));
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

如果多次序列化同一個可變Java對象時，只有第一次序列化時才會把該Java對象轉(zhuǎn)換成字節(jié)序列并輸出

當(dāng)使用Java序列化機(jī)制序列化可變對象時，只有第一次調(diào)用WriteObject()方法來輸出對象時才會將對象轉(zhuǎn)換成字節(jié)序列，并寫入到ObjectOutputStream；即使在后面程序中，該對象的實例變量發(fā)生了改變，再次調(diào)用WriteObject()方法輸出該對象時，改變后的實例變量也不會被輸出

import java.io.*;

public class SerializeMutable
{
    public static void main(String[] args)
    {

        try(
            // 創(chuàng)建一個ObjectOutputStream輸入流
            ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("mutable.txt"));
            // 創(chuàng)建一個ObjectInputStream輸入流
            ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("mutable.txt")))
        {
            NbaPlayer player = new NbaPlayer("斯蒂芬?guī)炖?, 30);
            // 系統(tǒng)會player對象轉(zhuǎn)換字節(jié)序列并輸出
            oos.writeObject(player);
            // 改變per對象的name實例變量
            player.setName("塞斯庫里");
            // 系統(tǒng)只是輸出序列化編號，所以改變后的name不會被序列化
            oos.writeObject(player);
            NbaPlayer player1 = (NbaPlayer)ois.readObject();    //①
            NbaPlayer player2 = (NbaPlayer)ois.readObject();    //②
            // 下面輸出true，即反序列化后player1等于player2
            System.out.println(player1 == player2);
            // 下面依然看到輸出"斯蒂芬?guī)炖?，即改變后的實例變量沒有被序列化
            System.out.println(player2.getName());
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

在一些特殊的場景下，如果一個類里包含的某些實例變量是敏感信息，這時不希望系統(tǒng)將該實例變量值進(jìn)行實例化；或者某個實例變量的類型是不可序列化的，因此不希望對該實例變量進(jìn)行遞歸實例化，以避免引發(fā)java.io.NotSerializableException異常

當(dāng)對某個對象進(jìn)行序列化時，系統(tǒng)會自動把該對象的所有實例變量依次進(jìn)行序列化，如果某個實例變量引用到另一個對象，則被引用的對象也會被序列化；如果被引用的對象的實例變量也引用了其他對象，則被引用的對象也會被序列化，這種情況被稱為遞歸序列化

在實例變量前面使用transient關(guān)鍵字修飾，可以指定java序列化時無須理會該實例變量

public class NbaPlayer implements java.io.Serializable
{
    private String name;
    private transient int number;
    // 注意此處沒有提供無參數(shù)的構(gòu)造器!
    public NbaPlayer(String name, int number)
    {
        System.out.println("有參數(shù)的構(gòu)造器");
        this.name = name;
        this.number = number;
    }
    
    // name的setter和getter方法
    public void setName(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return this.name;
    }

    // number的setter和getter方法
    public void setNumber(int number)
    {
        this.number = number;
    }
    public int getNumber()
    {
        return this.number;
    }
}

transient關(guān)鍵字只能用于修飾實例變量，不可修飾Java程序中的其他成分

import java.io.*;

public class TransientTest
{
    public static void main(String[] args)
    {
        try(
            // 創(chuàng)建一個ObjectOutputStream輸出流
            ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("transient.txt"));
            // 創(chuàng)建一個ObjectInputStream輸入流
            ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("transient.txt")))
        {
            NbaPlayer per = new NbaPlayer("克萊湯普森", 11);
            // 系統(tǒng)會per對象轉(zhuǎn)換字節(jié)序列并輸出
            oos.writeObject(per);
            NbaPlayer p = (NbaPlayer)ois.readObject();
            System.out.println(p.getNumber());
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

在序列化和反序列化過程中需要特殊處理的類應(yīng)該提供如下特殊簽名的方法，這些特殊的方法用以實現(xiàn)自定義：

private void writeObject(java.io.ObjectOutputStream out) throws IOException

private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException

private void readObjectNoData() throws ObjectStreamException

writeObject()方法負(fù)責(zé)寫入特定類的實例的狀態(tài)，以便相應(yīng)的readObject()方法可以恢復(fù)它。通過重寫該方法，可以完全獲得對序列化機(jī)制的控制，自主決定哪些實例變量需要序列化，怎樣序列化。在默認(rèn)情況下，該方法會調(diào)用out.defaultWriteObject來保存Java對象的各實例變量，從而可以實現(xiàn)序列化Java對象狀態(tài)的目的

readObject()方法負(fù)責(zé)從流中讀取并恢復(fù)對象實例變量，通過重寫該方法，可以完全獲得對反序列化機(jī)制的控制，可以自主決定需要反序列化哪些實例變量，怎樣反序列化。在默認(rèn)情況下，該方法會調(diào)用in.defaultReadObject來恢復(fù)Java對象的非瞬態(tài)實例變量

通常情況下readObject()方法與writeObject()方法對應(yīng)，如果writeObject()方法中對Java對象的實例變量進(jìn)行了一些處理，則應(yīng)該在readObject()方法中對該實例變量進(jìn)行相應(yīng)的反處理，以便正確恢復(fù)該對象

當(dāng)序列化流不完整時，readObjectNoData()方法可以用來正確地初始化反序列化的對象

import java.io.IOException;

public class NbaPlayer implements java.io.Serializable
{
    private String name;
    private int number;
    // 注意此處沒有提供無參數(shù)的構(gòu)造器!
    public NbaPlayer(String name, int number)
    {
        System.out.println("有參數(shù)的構(gòu)造器");
        this.name = name;
        this.number = number;
    }
    
    // name的setter和getter方法
    public void setName(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return this.name;
    }

    // number的setter和getter方法
    public void setNumber(int number)
    {
        this.number = number;
    }
    public int getNumber()
    {
        return this.number;
    }
    
    private void writeObject(java.io.ObjectOutputStream out) throws IOException
    {
        // 將name實例變量值反轉(zhuǎn)后寫入二進(jìn)制流
        out.writeObject(new StringBuffer(name).reverse());
        out.writeInt(number);
    }
    
    private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException
    {
        // 將讀取的字符串反轉(zhuǎn)后賦給name實例變量
        this.name = ((StringBuffer)in.readObject()).reverse().toString();
        this.number = in.readInt();
    }
}

writeObject()方法存儲實例變量的順序應(yīng)該和readObject()方法中恢復(fù)實例變量的順序一致，否則將不能正?；謴?fù)該Java對象

ANY-ACCESS-MODIFIER Object writeReplace() 實現(xiàn)序列化某個對象時替換該對象

此writeReplace()方法將由序列化機(jī)制調(diào)用，只要該方法存在。因為該方法可以擁有私有(private)，受保護(hù)的(protected)和包私有(package-private)等訪問權(quán)限，所以其子類有可能獲得該方法

下面程序的writeReplace()方法，這樣可以在寫入NbaPlayer對象時將該對象替換成ArrayList

// 重寫writeReplace方法，程序在序列化該對象之前，先調(diào)用該方法
private Object writeReplace() throws ObjectStreamException
{
    ArrayList