序列化是指将对象的状态信息转换为可以存储或传输的形式的过程。
在Java中创建的对象,只要没有被回收就可以被复用,但是,创建的这些对象都是存在于JVM的堆内存中,JVM处于运行状态时候,这些对象可以复用,
但是一旦JVM停止,这些对象的状态也就丢失了。
在实际生活中,需要将对象持久化,需要的时候再重新读取出来,通过对象序列化,可以将对象的状态保存为字节数组,需要的时候再将字节数组反序列化为对象。
对象序列化可以很容易的在JVM中的活动对象和字节数组(流)之间转换,广泛用于RMI(远程方法调用)以及网络传输中。
特别注意:
a.静态成员变量属于类不属于对象,所以不会参与序列化(对象序列化保存的是对象的“状态”,也就是它的成员变量,因此序列化不会关注静态变量)
b.用transient关键字标记的成员变量不参与序列化(在被反序列化后,transient 变量的值被设为初始值,如 int 型的是 0,对象型的是 null)
(1).Serializable
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 }
![](https://img.laitimes.com/img/__Qf2AjLwojIjJCLyojI0JCLicmbw5SNwMTM5cTMzkTMtQzM4YDN4IjMygTMzAjNxAjMtYjN5YzN18CXzAjNxAjMvwlN2kjN3UzLcd2bsJ2Lc12bj5ycn9Gbi52YuUTMwIzcldWYtl2Lc9CX6MHc0RHaiojIsJye.png)
在使用时,通常是和
ObjectOutputStream
以及
ObjectInputStream
配套一起使用,准确的说是和
ObjectOutputStream
里的
writeObject ()
和
ObjectInputStream
里的
readObject ()
一起使用。
writeObject()
方法是最重要的方法,用于对象序列化。如果对象包含其他对象的引用,则writeObject()方法递归序列化这些对象。
(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
转载于:https://www.cnblogs.com/wufeng0927/p/5281884.html