Serializable and Parcelable

android 中自定义的对象序列化的问题有两个选择一个是Parcelable，另外一个是Serializable。
Serializable接口是Java SE本身就支持的，而Parcelable是Android特有的功能，效率比实现Serializable接口高，但是实现比Serializable复杂

1、序列化是干什么的？
       简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保 存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。

2、什么情况下需要序列化  
    a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
    b）当你想用套接字在网络上传送对象的时候；
    c）当你想通过RMI传输对象的时候；

用途：利用对象的串行化实现保存应用程序的当前工作状态，下次再启动的时候将自动地恢复到上次执行的状态。

二 至于选取哪种可参考下面的原则：
1.在使用内存的时候，Parcelable 类比Serializable性能高，所以推荐使用Parcelable类。
2.Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3.Parcelable不能使用在要将数据存储在磁盘上的情况

 Java 串行化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。这种机制允许你将对象通过网络进行传播，并可以随时把对象持久化到数据库、文件等系统里

 

package one;

import java.io.Serializable;

 public class Student implements Serializable{

     private int id;
     private String name;
     
     public Student(){
         
     }
     
     public Student(int id, String name) {
         this.id = id;
         this.name = name;
     }
     
     public void setID(int id) {
         this.id = id;
     }
     
     public void setName(String name) {
         this.name = name;
     }
     
     public int getID() {
         return id;
     }
     
     public String getName() {
         return name;
     }
}

package one;

import java.io.Serializable;
import java.util.ArrayList;

public class Shit implements Serializable{
    
    ArrayList<Student> studentList;
    
    public Shit(){
        studentList = new ArrayList<Student>();
    }
    
    public void setStudentList(ArrayList<Student> list) {
        studentList = list;
    }
    
    public ArrayList<Student> getStudentList() {        
        return studentList;
    }

}

package one;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

public class Test {

    public static void main(String args[]) {
        Student student1 = new Student(1, "yi");
        Student student2 = new Student(2, "er");
        Shit shit = new Shit();
        ArrayList<Student> list = shit.getStudentList();
        list.add(student1);
        list.add(student2);

        ArrayList<Student> list1 = shit.getStudentList();

        for (Student student : list1) {
            System.out.println("id:" + student.getID() + " name:"
                    + student.getName());
        }

        // 对象序列化
        try {
            FileOutputStream fos = new FileOutputStream("/home/daichenghui/cc/catDemo.out");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(shit);
            oos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("-------re-Serializable-------");
        // 反序列化
        Shit shit1 = null;
        try {
            FileInputStream fis = new FileInputStream("/home/daichenghui/cc/catDemo.out");
            ObjectInputStream ois = new ObjectInputStream(fis);
            shit1 = (Shit) ois.readObject();
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        if (shit1 != null) {
            ArrayList<Student> list2 = shit.getStudentList();
            for (Student student : list2) {
                System.out.println("id:" + student.getID() + " name:"
                        + student.getName());
            }
        }
    }
}

id:1 name:yi
id:2 name:er
-------re-Serializable-------
id:1 name:yi
id:2 name:er

Note：java序列化每个文件只能存储一个对象。该对象的成员如果不是基本类型，则必须也要实现java.io.Serializable

 

串行化的特点：

    如果某个类能够被串行化，其子类也可以被串行化。如果该类有父类，则分两种情况来考虑，如果该父类已经实现了可串行化接口。则其父类的相应字段及属性的处理和该类相同；如果该类的父类没有实现可串行化接口，则该类的父类所有的字段属性将不会串行化。

 //writeObject和readObject本身就是线程安全的，传输过程中是不允许被并发访问的。所以对象能一个一个接连不断的传过来