【Android基础】序列化 Serializable vs Parcelable

Serializable

public class SerializableDeveloper implements Serializable
String name;
int yearsOfExperience;
List<Skill> skillSet;
float favoriteFloat;

static class Skill implements Serializable {
String name;
boolean programmingRelated;
}
}

只要保证类以及其属性类都继承了Serializable就可以了，很easy了。

Parcelable

不好的地方 就是继承Parcelable后，需要覆写一坨方法（主要是序列化读写接口），但基本上AS可以全部自动生成，所以也没有想象的那么复杂。

如下对象:

class ParcelableDeveloper {
String name;
int yearsOfExperience;
List<Skill> skillSet;
float favoriteFloat;

public ParcelableDeveloper(String name, int yearsOfExperience, List<Skill> skillSet, float favoriteFloat) {
this.name = name;
this.yearsOfExperience = yearsOfExperience;
this.skillSet = skillSet;
this.favoriteFloat = favoriteFloat;
}
}

IDE自动会生成:

class ParcelableDeveloper implements Parcelable {
String name;
int yearsOfExperience;
List<Skill> skillSet;
float favoriteFloat;

public ParcelableDeveloper(String name, int yearsOfExperience, List<Skill> skillSet, float favoriteFloat) {
this.name = name;
this.yearsOfExperience = yearsOfExperience;
this.skillSet = skillSet;
this.favoriteFloat = favoriteFloat;
}

protected ParcelableDeveloper(Parcel in) {
name = in.readString();
yearsOfExperience = in.readInt();
skillSet = in.createTypedArrayList(Skill.CREATOR);
favoriteFloat = in.readFloat();
}

public static final Creator<ParcelableDeveloper> CREATOR = new Creator<ParcelableDeveloper>() {
@Override
public ParcelableDeveloper createFromParcel(Parcel in) {
return new ParcelableDeveloper(in);
}

@Override
public ParcelableDeveloper[] newArray(int size) {
return new ParcelableDeveloper[size];
}
};

@Override
public int describeContents() {
return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeInt(yearsOfExperience);
dest.writeTypedList(skillSet);
dest.writeFloat(favoriteFloat);
}
}

嵌套对象也需要实现Parcelable

如上面中的Skill对象

public class Skill implements Parcelable {
public String skillname;

public Skill(String skillname) {
this.skillname = skillname;
}

protected Skill(Parcel in) {
skillname = in.readString();
}

public static final Creator<Skill> CREATOR = new Creator<Skill>() {
@Override
public Skill createFromParcel(Parcel in) {
return new Skill(in);
}

@Override
public Skill[] newArray(int size) {
return new Skill[size];
}
};

@Override
public int describeContents() {
return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(skillname);
}
}

哪里可以使用Parcelable对象？

就我所知，Activity之间数据的传递,比如:

public class ParcelableFromActivity extends AppCompatActivity {
ParcelableDeveloper pd;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_parcelable);

List<Skill> skillList = new ArrayList<>();
skillList.add(new Skill("java"));
pd = new ParcelableDeveloper("jason", 6, skillList, 2);
TextView tv = (TextView) findViewById(R.id.content);
tv.setText(pd.name + " 经验:" + pd.yearsOfExperience + "年 技能:" + pd.skillSet.get(0).skillname);
}

public void jump(View view) {
Intent i = new Intent(this, ParcelableToActivity.class);

Bundle b = new Bundle();
b.putParcelable(ParcelableToActivity.PARCEL, pd);
i.putExtra(ParcelableToActivity.BUNDLE, b);

startActivity(i);
}
}

为什么要创造出Parcelable？

据说是因为效率原因，Serializable用起来是方便，但他是用反射来实现序列化的，所以效率是瓶颈。下图是效率对比:



Parcelable 比 Serializable快了10多倍。有趣的是，即使在Nexus 10这样性能强悍的硬件上，一个相当简单的对象的序列化和反序列化的过程要花将近一毫秒。

所以在碰到大量需要序列化的场景，还是使用Parcelable吧，毕竟效率性能伤不起啊

参考:

这哥们讲的还蛮详细

国外的一篇译文