android 对象序列化Parcelable，Serializable详解
- Parcelable接口
Interface for classes whose instances can be written to and restored from a Parcel。 Classes implementing the Parcelable interface must also have a static field called CREATOR， which is an object implementing the Parcelable.Creator interface。
2.实现Parcelable就是为了进行序列化，那么，为什么要序列化？
1）永久性保存对象，保存对象的字节序列到本地文件中；
2）通过序列化对象在网络中传递对象；
3）通过序列化在进程间传递对象。
3.实现序列化的方法
Android中实现序列化有两个选择：一是实现Serializable接口（是JavaSE本身就支持的），一是实现Parcelable接口（是Android特有功能，效率比实现Serializable接口高效，可用于Intent数据传递，也可以用于进程间通信（IPC））。实现Serializable接口非常简单，声明一下就可以了，而实现Parcelable接口稍微复杂一些，但效率更高，推荐用这种方法提高性能。
注：Android中Intent传递对象有两种方法：一是Bundle.putSerializable(Key，Object)，另一种是Bundle.putParcelable(Key，Object)。当然这些Object是有一定的条件的，前者是实现了Serializable接口，而后者是实现了Parcelable接口。
4.选择序列化方法的原则
1）在使用内存的时候，Parcelable比Serializable性能高，所以推荐使用Parcelable。
2）Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3）Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。尽管Serializable效率低点，但此时还是建议使用Serializable 。
5.应用场景
需要在多个部件(Activity或Service)之间通过Intent传递一些数据，简单类型（如：数字、字符串）的可以直接放入Intent。复杂类型必须实现Parcelable接口。
6、Parcelable接口定义
public interface Parcelable
{
//内容描述接口，基本不用管
public int describeContents();
//写入接口函数，打包
public void writeToParcel(Parcel dest, int flags);
//读取接口，目的是要从Parcel中构造一个实现了Parcelable的类的实 例处理。因为实现类在这里还是不可知的，所以需要用到模板的方式，继承类名通过模板参数传入
//为了能够实现模板参数的传入，这里定义Creator嵌入接口,内含两个接口函数分别返回单个和多个继承类实例
public interface Creator
{
public T createFromParcel(Parcel source);
public T[] newArray(int size);
}
} 7、实现Parcelable步骤
1）implements Parcelable
2）重写writeToParcel方法，将你的对象序列化为一个Parcel对象，即：将类的数据写入外部提供的Parcel中，打包需要传递的数据到Parcel容器保存，以便从 Parcel容器获取数据
3）重写describeContents方法，内容接口描述，默认返回0就可以
4）实例化静态内部对象CREATOR实现接口Parcelable.Creator
public static final Parcelable.Creator CREATOR
注：其中public static final一个都不能少，内部对象CREATOR的名称也不能改变，必须全部大写。需重写本接口中的两个方法：createFromParcel(Parcel in) 实现从Parcel容器中读取传递数据值，封装成Parcelable对象返回逻辑层，newArray(int size) 创建一个类型为T，长度为size的数组，仅一句话即可（return new T[size]），供外部类反序列化本类数组使用。
简而言之：通过writeToParcel将你的对象映射成Parcel对象，再通过createFromParcel将Parcel对象映射成你的对象。也可以将Parcel看成是一个流，通过writeToParcel把对象写到流里面，在通过createFromParcel从流里读取对象，只不过这个过程需要你来实现，因此写的顺序和读的顺序必须一致。
代码如下：
声明：WorkBean类
/**
* 1、Parcelable比Serializable效率高，
*
*/
public class WorkBean implements Parcelable {
// 普通常量按Parcelable提供的方法直接操作即可
private int keyId;
private String address;
public HashMap map = new HashMap();
// 声明boolean变量，在传值时需要依据true，false来设置1,0转换为byte字节进行写入和读取时则相反
private boolean isOk;
// 声明list对象集合
private ArrayList listAccount = new ArrayList();
// 继承了Serializeable
private AccountBean myAccount;
// 继承了Parcelable的对象
private Student stu;
private static String[] arrayStr;
public WorkBean() {
}
public WorkBean(int keyId, String address, HashMap map,
boolean isOk, ArrayList listAccount,
AccountBean myAccount, Student stu, String[] arrayStr) {
this.keyId = keyId;
this.address = address;
this.map = map;
this.isOk = isOk;
this.listAccount = listAccount;
this.myAccount = myAccount;
this.stu = stu;
this.arrayStr = arrayStr;
}
public HashMap getMap() {
return map;
}
public void setMap(HashMap map) {
this.map = map;
}
public ArrayList getListAccount() {
return listAccount;
}
public void setListAccount(ArrayList listAccount) {
this.listAccount = listAccount;
}
public AccountBean getMyAccount() {
return myAccount;
}
public void setMyAccount(AccountBean myAccount) {
this.myAccount = myAccount;
}
public Student getStu() {
return stu;
}
public void setStu(Student stu) {
this.stu = stu;
}
@Override
public int describeContents() {
return 0;
}
public int getKeyId() {
return keyId;
}
public void setKeyId(int keyId) {
this.keyId = keyId;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "WorkBean [keyId=" + keyId + ", address=" + address
+ ", map.name=" + map.get("name") + ",map.age:"
+ map.get("age") + ", isOk=" + isOk + ", listAccount="
+ listAccount + ", myAccount=" + myAccount + ", stu=" + stu
+ ", arrayStr=" + Arrays.toString(arrayStr) + "]";
}
@Override
public void writeToParcel(Parcel dest, int flags) {
// 常规写入
dest.writeInt(keyId);
dest.writeString(address);
if (arrayStr == null) {
dest.writeInt(0);
} else {
dest.writeInt(arrayStr.length);
}
if (arrayStr != null) {
dest.writeStringArray(arrayStr);
}
// 注意：写入boolean
dest.writeByte((byte) (isOk ? 1 : 0));
dest.writeList(listAccount);
// 注意：写入序列化的对象
dest.writeSerializable(myAccount);
dest.writeParcelable(stu, flags);
// 写入HashMap()对象
dest.writeMap(map);
}
// 必须声明公开静态的，名称为CREATOR的成员变量方法，否则会在获取数据时报：android.os.BadParcelableException
public static final Parcelable.Creator CREATOR = new Creator() {
@Override
public WorkBean[] newArray(int size) {
return new WorkBean[size];
}
// 在读取Parcel容器里的数据时，必须按成员变量声明的顺序读取数据
@Override
public WorkBean createFromParcel(Parcel source) {
WorkBean workBean = new WorkBean();
workBean.keyId = source.readInt();
workBean.address = source.readString();
int length = source.readInt();
String[] tempStr = null;
if (length > 0) {
tempStr = new String[length];
source.readStringArray(tempStr);
}
workBean.isOk = source.readByte() == 1 ? true : false;
workBean.listAccount = source.readArrayList(AccountBean.class
.getClassLoader());
workBean.myAccount = (AccountBean) source.readSerializable();
workBean.stu = source
.readParcelable(Student.class.getClassLoader());
workBean.map = source.readHashMap(HashMap.class.getClassLoader());
return workBean;
}
};
/**
* (1、)Caused By：android.os.BadParcelableException: ClassNotFoundException
* when unmarshalling，原因是ClassLoader设置不对，或者没有传入ClassLoader。
*
* (2、)java.lang.RuntimeException: Parcelable encountered IOException
* writing serializable
* object，原因是传递的Parcelable对象里面的对象也要Parcelable或者Serializable。
*/
}
**声明AccountBean 类：**
/**
* 一个对象序列化的接口，一个类只有实现了Serializable接口，它的对象才是可序列化的。因此如果要序列化某些类的对象，
* 这些类就必须实现Serializable接口
* 。而实际上，Serializable是一个空接口，没有什么具体内容，它的目的只是简单的标识一个类的对象可以被序列化。
*
*/
public class AccountBean implements Serializable {
// 1、如果在这个里面也添加自定义的类也是要实现Serializable,否则会报NotSerializableException；
// 2、在Parcelable中可以使用Serializable，但在Serializable不可用Parcelable,否则会报：java.io.NotSerializableException异常
// 3、传递枚举enum的话，把枚举当做类来看就行了
private static final long serialVersionUID = -6738248150126276047L;
private String account;
private String password;
public AccountBean(String account, String password) {
this.account = account;
this.password = password;
}
public AccountBean() {
}
@Override
public String toString() {
return "AccountBean [account=" + account + ", password=" + password
+ "]";
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
**声明Student类：**
public class Student implements Parcelable {
private int classNum;
private String name;
private int age;
private boolean s;
public int getClassNum() {
return classNum;
}
public void setClassNum(int classNum) {
this.classNum = classNum;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isS() {
return s;
}
public void setS(boolean s) {
this.s = s;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [classNum=" + classNum + ", name=" + name + ", age="
+ age + ", s=" + s + "]";
}
public Student(int classNum, String name, int age, boolean s) {
super();
this.classNum = classNum;
this.name = name;
this.age = age;
this.s = s;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(classNum);
dest.writeString(name);
dest.writeInt(age);
dest.writeByte((byte) (s ? 1 : 0));
}
// 生成静态的方法
public static final Parcelable.Creator CREATOR = new Creator() {
@Override
public Student[] newArray(int size) {
return new Student[size];
}
@Override
public Student createFromParcel(Parcel source) {
Student student = new Student();
student.classNum = source.readInt();
student.name = source.readString();
student.age = source.readInt();
student.s = source.readByte() == 1 ? true : false;
return student;
}
};
} 8、Serializable实现与Parcelabel实现的区别
1）Serializable的实现，只需要implements Serializable 即可。这只是给对象打了一个标记，系统会自动将其序列化。
2）Parcelabel的实现，不仅需要implements Parcelabel，还需要在类中添加一个静态成员变量CREATOR，这个变量需要实现 Parcelable.Creator 接口。
发送序列化后的对象：
AccountBean accountBean = new AccountBean("account", "123456");
ArrayList listAccount = new ArrayList();
listAccount.add(accountBean);
String[] tempStr = { "01", "02", "03" };
HashMap<String,String> map=new HashMap<String, String>();
map.put("name", "xiaohui");
map.put("age", "002");
// 初始化对象
WorkBean workbean = new WorkBean(002, "china shanghai",
map, false, listAccount, accountBean, new Student(02, "xiaohui", 25,
true), tempStr);
ArrayList listwork = new ArrayList();
listwork.add(workbean);
Intent mIntent = new Intent();
mIntent.setAction(Battery_level);
mIntent.putExtra("battery", mBatteryLevel);
mIntent.putExtra("workbean", listwork.get(0));
context.sendBroadcast(mIntent);
// 接受到序列化的对象
WorkBean parcelable = intent.getParcelableExtra("workbean");
Log.i(TAG, "parcelable:" + parcelable.toString());