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吧,毕竟效率性能伤不起啊