序列化與反序列化總結(Serializable和Parcelable)

序列化是指將對象的狀態信息轉換為可以存儲或傳輸的形式的過程。

在Java中創建的對象，只要沒有被回收就可以被復用，但是，創建的這些對象都是存在於JVM的堆內存中，JVM處於運行狀態時候，這些對象可以復用，

但是一旦JVM停止，這些對象的狀態也就丟失了。

在實際生活中，需要將對象持久化，需要的時候再重新讀取出來，通過對象序列化，可以將對象的狀態保存為字節數組，需要的時候再將字節數組反序列化為對象。

對象序列化可以很容易的在JVM中的活動對象和字節數組(流)之間轉換，廣泛用於RMI(遠程方法調用)以及網絡傳輸中。

 

特別注意：

a.靜態成員變量屬於類不屬於對象，所以不會參與序列化(對象序列化保存的是對象的“狀態”，也就是它的成員變量，因此序列化不會關注靜態變量)

b.用transient關鍵字標記的成員變量不參與序列化(在被反序列化后，transient 變量的值被設為初始值，如 int 型的是 0，對象型的是 null)

 

(1).Serializable

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"></uses-permission>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>

import java.io.Serializable;

public class StudentSerializable implements Serializable {
    
    //指定serialVersionUID，
    //因為原則上序列化后的數據中的serialVersionUID只有和當前類的serialVersionUID相同時才能被正常的反序列化
    //最好自己指定UID或者系統生成，因為如果增加或者刪除了某些成員變量，那么系統就會重新生成hash值然后賦給UID，導致反序列化時候crash
    private static final long serialVersionUID = 10000000000000000L; 
    
    private int Uid;
    private String Name ;
    
    public int getUid() {
        return Uid;
    }
    public void setUid(int uid) {
        Uid = uid;
    }
    public String getName() {
        return Name;
    }
    public void setName(String name) {
        Name = name;
    }
    @Override
    public String toString() {
        return "StudentSerializable [Uid=" + Uid + ", Name=" + Name + "]";
    }

}

private void DealSerializable() throws IOException {
        // Initializes The Object
        StudentSerializable stu = new StudentSerializable();
        stu.setUid(9027);
        stu.setName("fish");        
        
        File extDir = Environment.getExternalStorageDirectory();
        String filename = "tempFile.txt";
        File fullFilename = new File(extDir, filename);
         
        try {
            fullFilename.createNewFile();
            fullFilename.setWritable(Boolean.TRUE);
            fullFilename.setReadable(Boolean.TRUE);
             
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        // Write Obj to File
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream(fullFilename.getAbsoluteFile()));
            oos.writeObject(stu);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //oos.close();
        }

        // Read Obj from File
        //File file = new File("tempFile.txt");
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(fullFilename.getAbsoluteFile()));
            StudentSerializable newStu = (StudentSerializable) ois.readObject();
            System.out.println(newStu);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            //ois.close();
        }
    }

 在使用時，通常是和ObjectOutputStream 以及 ObjectInputStream 配套一起使用，准確的說是和ObjectOutputStream 里的writeObject () 和 ObjectInputStream 里的 readObject () 一起使用。writeObject()方法是最重要的方法，用於對象序列化。如果對象包含其他對象的引用，則writeObject()方法遞歸序列化這些對象。

 

(2).Parcelable

import android.os.Parcel;
import android.os.Parcelable;

public class StudentParcelable implements Parcelable{
    
    private int Uid;
    private String Name ;
    
    private Book book ;
    
    public StudentParcelable(int uid, String name) {
        super();
        Uid = uid;
        Name = name;
    }
    
    public int getUid() {
        return Uid;
    }
    public void setUid(int uid) {
        Uid = uid;
    }
    public String getName() {
        return Name;
    }
    public void setName(String name) {
        Name = name;
    }


    //功能：返回當前對象的內容描述，如果含有文件描述符，返回1
    //即CONTENTS_FILE_DESCRIPTOR
    //幾乎所有情況都會返回0
    @Override
    public int describeContents() {
        // TODO Auto-generated method stub
        return 0;
    }

    /**
     * 序列化功能由writeToParcel完成，最終通過Parcel的一系列Write方法完成
     */
    //功能：將當前對象寫入序列化結構中，其中flags標識有兩種值，0或1
    //為1時標識當前對象需要作為返回值返回，不能立刻釋放資源，即PARCELABLE_WRITE_RETURN_VALUE
    //不過幾乎所有情況都為0
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        // TODO Auto-generated method stub
        dest.writeInt(Uid);
        dest.writeString(Name);
        dest.writeParcelable(book, 0);
    }
    
    /**
     * 反序列化由CREATOR來完成，其內部標明了如何創建序列化對象和數組
     * 並通過Parcel的一系列read方法來完成反序列化
     */
    public StudentParcelable(Parcel source){
        Uid = source.readInt();
        Name = source.readString();
        
        //注意：book是一個可序列化對象，所以它的反序列化過程需要傳遞當前線程的上下文類加載器
        //否則會報找不到類的錯誤
        book = source.readParcelable(Thread.currentThread().getContextClassLoader());
    }
    
    public static final Parcelable.Creator<StudentParcelable> CREATOR = new Parcelable.Creator<StudentParcelable>() {

        //功能： 從Parcel容器中讀取傳遞數據值，封裝成Parcelable對象返回邏輯層。
        @Override
        public StudentParcelable createFromParcel(Parcel source) {
            // TODO Auto-generated method stub
            return new StudentParcelable(source);
        }

        //功能：創建一個類型為T，長度為size的數組，僅一句話（return new T[size])即可。方法是供外部類反序列化本類數組使用。
        @Override
        public StudentParcelable[] newArray(int size) {
            // TODO Auto-generated method stub
            return new StudentParcelable[size];
        }
    }; 
    

}

Intent intent = new Intent(this,Second.class);
StudentParcelable stu = new StudentParcelable(001,"fish");
intent.putExtra("student", stu);
startActivity(intent);

Intent intent = getIntent();
StudentParcelable stu = (StudentParcelable) intent.getParcelableExtra("student");
Log.i("LOG", "student name :" + stu.getName());
Log.i("LOG", "student age :" + stu.getUid());

 

兩者區別：

1.Serializable實現簡單，而Parcelable需要實現特殊的接口

2.Serializable將對象轉化為字節流存儲在外部設備，需要時重新生成對象(依靠反射)，因為使用反射，所以會產生大量的臨時變量，從而引起頻繁的GC，相比之下Parcelable性能更高，Parcelable的效率是Serializable的十倍以上，所以在內存中傳輸時更推薦Parcelable(比如在網絡中傳輸對象或者進程間傳輸對象，還有Intent)

3.Parcelable的整個過程都在內存中進行，反序列化讀取的就是原對象，不會創建新對象。要注意的是：不能使用要將數據存儲在磁盤上(比如永久性保存對象，或者保存對象的字節序列到本地文件中)，因為Parcel是為了更好的實現在IPC間傳遞對象，並不是一個通用的序列化機制，當改變任何Parcel中數據的底層實現都可能導致之前的數據不可讀取(Parcelable 是以2進制的方式寫入，嚴重依賴寫入順序)，還有就是Parcelable為了效率完全沒有考慮版本間的兼容性，所以數據持久化還是要使用Serializable(比如外部設備保存對象狀態或者網絡傳輸對象)

快速解析和序列化Json對象的類庫：LoganSquare

 

注意：

1.如果一個類想被序列化，需要實現Serializable接口。否則將拋出NotSerializableException異常，這是因為，在序列化操作過程中會對類型進行檢查，要求被序列化的類必須屬於Enum、Array和Serializable類型其中的任何一種，這也是為什么Serializable雖然是一個空接口，但是只要實現了該接口就能序列化和反序列化。

2.在類中增加writeObject 和 readObject 方法可以實現自定義序列化策略，雖然這倆方法不是被顯示調用，但是因為在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法時，會通過反射的方式調用到它們。

參考：http://www.hollischuang.com/archives/1140#What%20Serializable%20Did