序列化与反序列化总结(Serializable和Parcelable)

时间 2019-11-10

标签序列总结 serializable parcelable 繁體版

原文原文链接

序列化是指将对象的状态信息转换为能够存储或传输的形式的过程。java

在Java中建立的对象，只要没有被回收就能够被复用，可是，建立的这些对象都是存在于JVM的堆内存中，JVM处于运行状态时候，这些对象能够复用，android

可是一旦JVM中止，这些对象的状态也就丢失了。git

在实际生活中，须要将对象持久化，须要的时候再从新读取出来，经过对象序列化，能够将对象的状态保存为字节数组，须要的时候再将字节数组反序列化为对象。github

对象序列化能够很容易的在JVM中的活动对象和字节数组(流)之间转换，普遍用于RMI(远程方法调用)以及网络传输中。数组

特别注意：网络

a.静态成员变量属于类不属于对象，因此不会参与序列化(对象序列化保存的是对象的“状态”，也就是它的成员变量，所以序列化不会关注静态变量)ide

b.用transient关键字标记的成员变量不参与序列化(在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null)性能

(1).Serializableui

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

 1 import java.io.Serializable;
 2 
 3 public class StudentSerializable implements Serializable {
 4     
 5     //指定serialVersionUID，
 6     //由于原则上序列化后的数据中的serialVersionUID只有和当前类的serialVersionUID相同时才能被正常的反序列化
 7     //最好本身指定UID或者系统生成，由于若是增长或者删除了某些成员变量，那么系统就会从新生成hash值而后赋给UID，致使反序列化时候crash
 8     private static final long serialVersionUID = 10000000000000000L; 
 9     
10     private int Uid;
11     private String Name ;
12     
13     public int getUid() {
14         return Uid;
15     }
16     public void setUid(int uid) {
17         Uid = uid;
18     }
19     public String getName() {
20         return Name;
21     }
22     public void setName(String name) {
23         Name = name;
24     }
25     @Override
26     public String toString() {
27         return "StudentSerializable [Uid=" + Uid + ", Name=" + Name + "]";
28     }
29 
30 }

 1 private void DealSerializable() throws IOException {
 2         // Initializes The Object
 3         StudentSerializable stu = new StudentSerializable();
 4         stu.setUid(9027);
 5         stu.setName("fish");        
 6         
 7         File extDir = Environment.getExternalStorageDirectory();
 8         String filename = "tempFile.txt";
 9         File fullFilename = new File(extDir, filename);
10          
11         try {
12             fullFilename.createNewFile();
13             fullFilename.setWritable(Boolean.TRUE);
14             fullFilename.setReadable(Boolean.TRUE);
15              
16         } catch (IOException e) {
17             // TODO Auto-generated catch block
18             e.printStackTrace();
19         }
20 
21         // Write Obj to File
22         ObjectOutputStream oos = null;
23         try {
24             oos = new ObjectOutputStream(new FileOutputStream(fullFilename.getAbsoluteFile()));
25             oos.writeObject(stu);
26         } catch (IOException e) {
27             e.printStackTrace();
28         } finally {
29             //oos.close();
30         }
31 
32         // Read Obj from File
33         //File file = new File("tempFile.txt");
34         ObjectInputStream ois = null;
35         try {
36             ois = new ObjectInputStream(new FileInputStream(fullFilename.getAbsoluteFile()));
37             StudentSerializable newStu = (StudentSerializable) ois.readObject();
38             System.out.println(newStu);
39         } catch (IOException e) {
40             e.printStackTrace();
41         } catch (ClassNotFoundException e) {
42             e.printStackTrace();
43         } finally {
44             //ois.close();
45         }
46     }

在使用时，一般是和ObjectOutputStream 以及 ObjectInputStream 配套一块儿使用，准确的说是和ObjectOutputStream 里的writeObject () 和 ObjectInputStream 里的 readObject () 一块儿使用。writeObject()方法是最重要的方法，用于对象序列化。若是对象包含其余对象的引用，则writeObject()方法递归序列化这些对象。this

(2).Parcelable

 1 import android.os.Parcel;
 2 import android.os.Parcelable;
 3 
 4 public class StudentParcelable implements Parcelable{
 5     
 6     private int Uid;
 7     private String Name ;
 8     
 9     private Book book ;
10     
11     public StudentParcelable(int uid, String name) {
12         super();
13         Uid = uid;
14         Name = name;
15     }
16     
17     public int getUid() {
18         return Uid;
19     }
20     public void setUid(int uid) {
21         Uid = uid;
22     }
23     public String getName() {
24         return Name;
25     }
26     public void setName(String name) {
27         Name = name;
28     }
29 
30 
31     //功能：返回当前对象的内容描述，若是含有文件描述符，返回1
32     //即CONTENTS_FILE_DESCRIPTOR
33     //几乎全部状况都会返回0
34     @Override
35     public int describeContents() {
36         // TODO Auto-generated method stub
37         return 0;
38     }
39 
40     /**
41      * 序列化功能由writeToParcel完成，最终经过Parcel的一系列Write方法完成
42      */
43     //功能：将当前对象写入序列化结构中，其中flags标识有两种值，0或1
44     //为1时标识当前对象须要做为返回值返回，不能马上释放资源，即PARCELABLE_WRITE_RETURN_VALUE
45     //不过几乎全部状况都为0
46     @Override
47     public void writeToParcel(Parcel dest, int flags) {
48         // TODO Auto-generated method stub
49         dest.writeInt(Uid);
50         dest.writeString(Name);
51         dest.writeParcelable(book, 0);
52     }
53     
54     /**
55      * 反序列化由CREATOR来完成，其内部标明了如何建立序列化对象和数组
56      * 并经过Parcel的一系列read方法来完成反序列化
57      */
58     public StudentParcelable(Parcel source){
59         Uid = source.readInt();
60         Name = source.readString();
61         
62         //注意：book是一个可序列化对象，因此它的反序列化过程须要传递当前线程的上下文类加载器
63         //不然会报找不到类的错误
64         book = source.readParcelable(Thread.currentThread().getContextClassLoader());
65     }
66     
67     public static final Parcelable.Creator<StudentParcelable> CREATOR = new Parcelable.Creator<StudentParcelable>() {
68 
69         //功能： 从Parcel容器中读取传递数据值，封装成Parcelable对象返回逻辑层。
70         @Override
71         public StudentParcelable createFromParcel(Parcel source) {
72             // TODO Auto-generated method stub
73             return new StudentParcelable(source);
74         }
75 
76         //功能：建立一个类型为T，长度为size的数组，仅一句话（return new T[size])便可。方法是供外部类反序列化本类数组使用。
77         @Override
78         public StudentParcelable[] newArray(int size) {
79             // TODO Auto-generated method stub
80             return new StudentParcelable[size];
81         }
82     }; 
83     
84 
85 }

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

1 Intent intent = getIntent();
2 StudentParcelable stu = (StudentParcelable) intent.getParcelableExtra("student");
3 Log.i("LOG", "student name :" + stu.getName());
4 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