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

参考:

这哥们讲的还蛮详细
国外的一篇译文