Java序列化與反序列化是什麼？為什麼需要序列化與反序列化？如何實作Java序列化與反序列化？本文圍繞這些問題進行了探讨。
Java序列化是指把Java對象轉換為位元組序列的過程；而Java反序列化是指把位元組序列恢複為Java對象的過程。
2.為什麼需要序列化與反序列化
我們知道，當兩個程序進行遠端通信時，可以互相發送各種類型的資料，包括文本、圖檔、音頻、視訊等， 而這些資料都會以二進制序列的形式在網絡上傳送。那麼當兩個Java程序進行通信時，能否實作程序間的對象傳送呢？答案是可以的。如何做到呢？這就需要Java序列化與反序列化了。換句話說，一方面，發送方需要把這個Java對象轉換為位元組序列，然後在網絡上傳送；另一方面，接收方需要從位元組序列中恢複出Java對象。
當我們明晰了為什麼需要Java序列化和反序列化後，我們很自然地會想Java序列化的好處。其好處一是實作了資料的持久化，通過序列化可以把資料永久地儲存到硬碟上（通常存放在檔案裡），二是，利用序列化實作遠端通信，即在網絡上傳送對象的位元組序列。
3.如何實作Java序列化與反序列化
1）JDK類庫中序列化API
java.io.ObjectOutputStream：表示對象輸出流
它的writeObject(Object obj)方法可以對參數指定的obj對象進行序列化，把得到的位元組序列寫到一個目标輸出流中。
java.io.ObjectInputStream：表示對象輸入流
它的readObject()方法源輸入流中讀取位元組序列，再把它們反序列化成為一個對象，并将其傳回。
2）實作序列化的要求
隻有實作了Serializable或Externalizable接口的類的對象才能被序列化，否則抛出異常。
3）實作Java對象序列化與反序列化的方法
假定一個Student類，它的對象需要序列化，可以有如下三種方法：
方法一：若Student類僅僅實作了Serializable接口，則可以按照以下方式進行序列化和反序列化
ObjectOutputStream采用預設的序列化方式，對Student對象的非transient的執行個體變量進行序列化。
ObjcetInputStream采用預設的反序列化方式，對對Student對象的非transient的執行個體變量進行反序列化。
方法二：若Student類僅僅實作了Serializable接口，并且還定義了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，則采用以下方式進行序列化與反序列化。
ObjectOutputStream調用Student對象的writeObject(ObjectOutputStream out)的方法進行序列化。
ObjectInputStream會調用Student對象的readObject(ObjectInputStream in)的方法進行反序列化。
方法三：若Student類實作了Externalnalizable接口，且Student類必須實作readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，則按照以下方式進行序列化與反序列化。
ObjectOutputStream調用Student對象的writeExternal(ObjectOutput out))的方法進行序列化。
ObjectInputStream會調用Student對象的readExternal(ObjectInput in)的方法進行反序列化。
4）JDK類庫中序列化的步驟
步驟一：建立一個對象輸出流，它可以包裝一個其它類型的目标輸出流，如檔案輸出流：
ObjectOutputStream out = new ObjectOutputStream(new fileOutputStream(“D:\\objectfile.obj”));
步驟二：通過對象輸出流的writeObject()方法寫對象：
out.writeObject(“Hello”);
out.writeObject(new Date());
5）JDK類庫中反序列化的步驟
步驟一：建立一個對象輸入流，它可以包裝一個其它類型輸入流，如檔案輸入流：
ObjectInputStream in = new ObjectInputStream(new fileInputStream(“D:\\objectfile.obj”));
步驟二：通過對象輸出流的readObject()方法讀取對象：
String obj1 = (String)in.readObject();
Date obj2 = (Date)in.readObject();
說明：為了正确讀取資料，完成反序列化，必須保證向對象輸出流寫對象的順序與從對象輸入流中讀對象的順序一緻。
為了更好地了解Java序列化與反序列化，選擇方法一編碼實作。
Student類定義如下：
package com.jieke.io;
import java.io.Serializable;
public class Student implements Serializable
{
private String name;
private char sex;
private int year;
private double gpa;
public Student()
{
}
public Student(String name,char sex,int year,double gpa)
this.name = name;
this.sex = sex;
this.year = year;
this.gpa = gpa;
public void setName(String name)
public void setSex(char sex)
public void setYear(int year)
public void setGpa(double gpa)
public String getName()
return this.name;
public char getSex()
return this.sex;
public int getYear()
return this.year;
public double getGpa()
return this.gpa;
}
把Student類的對象序列化到檔案O:\\Java\\com\\jieke\\io\\student.txt，并從該檔案中反序列化，向console顯示結果。代碼如下：
import java.io.*;
public class UseStudent
public static void main(String[] args)
Student st = new Student("Tom",'M',20,3.6);
File file = new File("O:\\Java\\com\\jieke\\io\\student.txt");
try
{
file.createNewFile();
}
catch(IOException e)
e.printStackTrace();
//Student對象序列化過程
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(st);
oos.flush();
oos.close();
fos.close();
//Student對象反序列化過程
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
Student st1 = (Student) ois.readObject();
System.out.println("name = " + st1.getName());
System.out.println("sex = " + st1.getSex());
System.out.println("year = " + st1.getYear());
System.out.println("gpa = " + st1.getGpa());
ois.close();
fis.close();
catch(ClassNotFoundException e)
catch (IOException e)
}
結果如下所示：
name = Tom
sex = M
year = 20
gpa = 3.6
總結：
1）Java序列化就是把對象轉換成位元組序列，而Java反序列化就是把位元組序列還原成Java對象。
2）采用Java序列化與反序列化技術，一是可以實作資料的持久化，在MVC模式中很是有用；二是可以對象資料的遠端通信。
Java的序列化機制隻序列化對象的屬性值，而不會去序列化什麼所謂的方法。
其實這個問題簡單思考一下就可以搞清楚，方法是不帶狀态的，就是一些指令，指令是不需要序列化的，隻要你的JVM classloader可以load到這個類，那麼類方法指令自然就可以獲得。序列化真正需要儲存的隻是對象屬性的值，和對象的類型。
這些知識找一本Java基礎程式設計的書，或者Java手冊就可以查到，我以為是不應該犯這種基本概念錯誤的。
我們可以做一個簡單的小試驗，來證明一下：
package com.javaeye;
public class DomainObject implements Serializable {
private String name;
private int age ;
public int getAge(); {
return age;
}
public void setAge(int age); {
this.age = age;
public String getName(); {
return name;
public void setName(String name); {
this.name = name;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class Main {
public static void main(String[] args); throws Exception {
DomainObject obj = new DomainObject();;
obj.setAge(29);;
obj.setName("fankai");;
FileOutputStream fos = new FileOutputStream("DomainObject");;
ObjectOutputStream oos = new ObjectOutputStream(fos);;
oos.writeObject(obj);;
oos.close();;
fos.close();;
DomainObject是我們準備序列化的類，在Main裡面，我們new一個DomainObject的對象，然後指派，最後把該對象序列化到一個硬碟檔案中。
然後使用一種支援二進制編輯器，例如UltraEdit打開這個檔案，看看Java都對DomainObject序列化了哪些資訊，你就什麼都明白了。
為了更友善觀察，我使用Linux下面的strings去提取文本資訊，輸出為：
root@linux:~>
strings DomainObject
com.javaeye.DomainObject
ageL
namet
Ljava/lang/String;xp
fankai
這些資訊很直覺的告訴我們序列化都儲存了些什麼内容：
1）對象的類型
2）對象屬性的類型
3）對象屬性的值
并沒有什麼方法簽名的資訊，更不要說什麼序列化方法了。
然後我們再做一個試驗，給DomainObject增加兩個方法：
public String toString(); {
return "This is a serializable test!";
public void doSomeWork(); {
System.out.println("hello");;
我們增加了toString方法和doSomeWork方法，按照你的理論，如果序列化方法的話，産生的檔案體積必然增大。記錄一下檔案體積，92Byte，好了，删除，運作程式，生成了新的檔案，看一下體積，還是92Byte！
拿到Linux下面再提取一下字元串：
root@linux:~> strings DomainObject
完全一模一樣！
然後我們再做第三個試驗，這次把DomainObject的兩個屬性以及相關方法删除掉：
修改Main類如下：
如果序列化方法的話，我們必然應該在檔案裡面發現方法的簽名資訊，甚至方法裡面包含的字元串，好了，再運作一遍，然後打開看一下吧！檔案現在體積變成了45Byte，拿到Linux下面提取一下資訊：
隻有對象的類型資訊，再無其它東西了！
請記住序列化機制隻儲存對象的類型資訊，屬性的類型資訊和屬性值，和方法沒有什麼關系，你就是給這個類增加10000個方法，序列化内容也不會增加任何東西
![Java String.format方法的簡單使用[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)