Parcelable vs Serializable

最新推荐文章于 2024-12-20 00:23:40 发布

原创最新推荐文章于 2024-12-20 00:23:40 发布 · 446 阅读

0 ·

CC 4.0 BY-SA版权

本文比较了在Android开发中使用Parcelable和Serializable两种方式来传递对象的优缺点。Parcelable提供了更高的效率，但实现较为复杂；而Serializable虽然实现简单，但在性能方面表现较差。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原文地址

本文翻译自：http://www.developerphil.com/parcelable-vs-serializable/

在开发android程序过程中，我们都遇到过使用bundle在activity之间传递对象的问题。实现使用bundle传递对象，有两种选择，一种是将对象通过Serialize（序列化）的方式传递，一种是将对象通过parcel（打包）的方式传递。本文比较这两种方式的区别。

Serializable简单为主

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

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

使用序列化方式实现对象传递的时候，只需要类及其内部类实现java.io.serialiable接口即可。java.io.serializable是一个没有任何待实现方法的标记接口。
序列化底层使用反射实现，效率较低，因为反射机制会生成大量的临时对象，并且直接对GC产生压力。

Parcelable高效是王

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

    ParcelableDeveloper(Parcel in) {
        this.name = in.readString();
        this.yearsOfExperience = in.readInt();
        this.skillSet = new ArrayList<Skill>();
        in.readTypedList(skillSet, Skill.CREATOR);
        this.favoriteFloat = in.readFloat();
    }

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

    int describeContents() {
        return 0;
    }

    static final Parcelable.Creator<ParcelableDeveloper> CREATOR
            = new Parcelable.Creator<ParcelableDeveloper>() 
        ParcelableDeveloper createFromParcel(Parcel in) {
            return new ParcelableDeveloper(in);
        }
        ParcelableDeveloper[] newArray(int size) {
            return new ParcelableDeveloper[size];
        }
    };

    static class Skill implements Parcelable {
        String name;
        boolean programmingRelated;

        Skill(Parcel in) {
            this.name = in.readString();
            this.programmingRelated = (in.readInt() == 1);
        }

        @Override
        void writeToParcel(Parcel dest, int flags) {
            dest.writeString(name);
            dest.writeInt(programmingRelated ? 1 : 0);
        }

        static final Parcelable.Creator<Skill> CREATOR 
            = new Parcelable.Creator<Skill>() {

            Skill createFromParcel(Parcel in) {
                return new Skill(in);
            }

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

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

根据google工程师的的观点，这种实现效率更高。原因之一是我们自己指定而非使用反射机制实现了保存和恢复的过程。并且在这个过程的自我实现中可以进行有效的优化。
然而，很显然，实现parcelable接口很费工夫，并且代码阅读性较低。

性能测试

下面比较两种实现方式具体的性能差异。
? 通过将对象放到bundle中并且取出，模仿activity传递对象的操作
? 重复这个过程1000次
? 执行十次取平均值
? 使用上文中的SerializableDeveloper和ParcelableDeveloper 进行测试
? 测试在下面三种设备上进行