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

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

但是一旦JVM停止，这些对象的状态也就丢失了。

在实际生活中，需要将对象持久化，需要的时候再重新读取出来，通过对象序列化，可以将对象的状态保存为字节数组，需要的时候再将字节数组反序列化为对象。

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

 

特别注意：

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

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

 

(1).Serializable

1 
     2 
     

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     @Override26     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 block18             e.printStackTrace();19         }20 21         // Write Obj to File22         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 File33         //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()方法递归序列化这些对象。

 

(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     //功能：返回当前对象的内容描述，如果含有文件描述符，返回132     //即CONTENTS_FILE_DESCRIPTOR33     //几乎所有情况都会返回034     @Override35     public int describeContents() {36         // TODO Auto-generated method stub37         return 0;38     }39 40     /**41      * 序列化功能由writeToParcel完成，最终通过Parcel的一系列Write方法完成42      */43     //功能：将当前对象写入序列化结构中，其中flags标识有两种值，0或144     //为1时标识当前对象需要作为返回值返回，不能立刻释放资源，即PARCELABLE_WRITE_RETURN_VALUE45     //不过几乎所有情况都为046     @Override47     public void writeToParcel(Parcel dest, int flags) {48         // TODO Auto-generated method stub49         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
     
       CREATOR = new Parcelable.Creator
      
       () {68 69         //功能： 从Parcel容器中读取传递数据值，封装成Parcelable对象返回逻辑层。70         @Override71         public StudentParcelable createFromParcel(Parcel source) {72             // TODO Auto-generated method stub73             return new StudentParcelable(source);74         }75 76         //功能：创建一个类型为T，长度为size的数组，仅一句话（return new T[size])即可。方法是供外部类反序列化本类数组使用。77         @Override78         public StudentParcelable[] newArray(int size) {79             // TODO Auto-generated method stub80             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对象的类库：

 

注意：

1.如果一个类想被序列化，需要实现Serializable接口。否则将抛出NotSerializableException异常，这是因为，在序列化操作过程中会对类型进行检查，要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种，这也是为什么Serializable虽然是一个空接口，但是只要实现了该接口就能序列化和反序列化。

2.在类中增加writeObject 和 readObject 方法可以实现自定义序列化策略，虽然这俩方法不是被显示调用，但是因为在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时，会通过反射的方式调用到它们。

参考：