序列化是指将对象的状态信息转换为可以存储或传输的形式的过程。
在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 }
(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(比如在网络中传输对象或者进程间传输对象)
3.Parcelable不能使用要将数据存储在磁盘上(比如永久性保存对象，或者保存对象的字节序列到本地文件中)，因为Parcel是为了更好的实现在IPC间传递对象，并不是一个通用的序列化机制，当改变任何Parcel中数据的底层实现都可能导致之前的数据不可读取，所以存储到磁盘还是要使用Serializable
注意：
1.如果一个类想被序列化，需要实现Serializable接口。否则将抛出NotSerializableException异常，这是因为，在序列化操作过程中会对类型进行检查，要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种，这也是为什么Serializable虽然是一个空接口，但是只要实现了该接口就能序列化和反序列化。
2.在类中增加writeObject 和 readObject 方法可以实现自定义序列化策略，虽然这俩方法不是被显示调用，但是因为在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时，会通过反射的方式调用到它们。
参考：http://www.hollischuang.com/archives/1140#What%20Serializable%20Did
序列化与反序列化总结(Serializable和Parcelable)
原文：http://www.cnblogs.com/wufeng0927/p/5281884.html