Android之Serializable和Parcelable区别

最新推荐文章于 2024-01-09 11:05:09 发布

转载最新推荐文章于 2024-01-09 11:05:09 发布 · 1.4k 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://www.cnblogs.com/leipDao/p/8022063.html

Android 同时被 2 个专栏收录

376 篇文章

订阅专栏

JAVA

104 篇文章

订阅专栏

本文详细介绍了Java序列化技术，包括Serializable和Parcelable两种方式。Serializable用于将对象的状态保存在硬盘上，而Parcelable则适用于在内存中快速传递对象。通过实现Serializable接口和Parcelable接口，可以轻松地将对象序列化和反序列化。本文提供了具体的实例代码，展示了如何在不同场景下选择合适的序列化方式。

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

一、什么是序列化？

我们无法直接将对象的引用传给Activity或者Fragment，需要将它们放到一个Intent或者Bundle里面，然后再传递，这时候就用到了序列化。

序列化是将对象的内容进行流化，然后对流化后的对象进行读、写操作，也可将流化后的对象传输于网络之间。
换句话说，序列化就是把你内存里的对象，进行整理，然后能够保存在硬盘或者进行网络传输。

序列化的实现：

实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，
使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，
使用ObjectOutputStream对象的writeObject(Object obj) 方法就可以将参数为obj的对象写出(即保存其状态)，
要恢复的话（反序列化）则用输入流。

反序列化：就是把字节序列恢复为Java对象的过程。但是我们要知道序列化与反序列化仅处理Java变量而不处理方法，仅对数据进行处理。

二、序列化两种方式

Android中序列化有两种方式：Serializable以及Parcelable。其中Serializable是Java自带的，而Parcelable是安卓专有的。

总结：两种序列化方式区别

两者区别在于存储媒介的不同。

Serializable 使用IO读写存储在硬盘上。序列化过程使用了反射技术，并且期间产生临时对象。优点代码少。
在使用内存的时候，Parcelable比Serializable性能高。
Parcelable 是直接在内存中读写，性能高十倍以上。内存的读写速度肯定优于硬盘读写速度，但是代码写起来相比Serializable方式麻烦一些。
Parcelable不能使用情况：将数据存储在磁盘。

要把对象保存在硬盘上，使用Serializable；
要在内存间传递对象，使用Parcelable；

通过比较发现，性能与简便我们只能选其一，建议使用Parcelable方式实现序列化，毕竟性能好很多，其实也没多麻烦。

三、Serializable方式序列化实例

serializable使用比较简单，只需要对某个类实现Serializable 接口即可。

Serializable 接口是一种标识接口，某个类实现Serializable 接口，Java便会对这个对象进行序列化操作。

我们编写Person类：

public class Person implements Serializable {

    private static final long serialVersionUID = -3139325922167935911L;
    //
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

很简单吧，无需过多解释。接下来我们就将这个类从一个Acticity传递到另一个Activity。

MainActivity:

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //
        Person p = new Person();
        p.setAge(18);
        p.setName("wanglei");
        //
        Intent i = new Intent(this, SecondActivity.class);
        i.putExtra("person", p);
        startActivity(i);
        
    }
}



public class SecondActivity extends Activity {

    private static final String TAG = "WL";

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

        Intent intent = getIntent();
        Person p=(Person) intent.getSerializableExtra("person");
        
        Log.i(TAG, "age = "+p.getAge());
        Log.i(TAG, "name = "+p.getName());
    }
}

以上代码及其简单了就不解释了，运行程序会看到如下打印：

以上就是Serializable方式序列化对象的举例，真的很简单，没有什么多余要解释的。

四、Parcelable方式序列化实例

关与Parcelable方式实现序列化会比Serializable 方法麻烦一些，大体步骤如下：

1. 实现Parcelable接口
2. 覆写describeContents方法，默认返回0。
3. 覆写writeToParcel(Parcel dest, int flags)方法，指定写入Parcel类的数据。
4. 创建Parcelable.Creator静态对象，覆写方法createFromParcel(Parcel in)与newArray(int size)。
Person类：

public class Person implements Parcelable {

    //
    private int age;
    private String name;
    private int weight;
    
    Person(){
        
    }
    
    Person(Parcel in){
        age = in.readInt();
        name = in.readString();
        weight = in.readInt();
    }


    //序列化时指定将哪些数据写入Parcel中，注意：写入顺序与读取顺序务必一致
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        //
        dest.writeInt(age);
        dest.writeString(name);
        dest.writeInt(weight);
    }
    
    //这里一定要写上public关键字，我测试如果不写会报异常，此外名字不能改必须为：CREATOR
    public static final Parcelable.Creator<Person> CREATOR = new Creator<Person>() {
        
        @Override
        public Person[] newArray(int size) {
            //
            return new Person[size];
        }
        
        //反序列化时从Parcel中读取数据
        @Override
        public Person createFromParcel(Parcel source) {
            // 
            return new Person(source);
        }
    };

    @Override
    public int describeContents() {
        //默认返回0即可
        return 0;
    }

    //
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
    
}

很多注意点都在注释中写出来了，仔细看注释即可。

Persons类：盛放Person类，主要演示如何序列化与反序列化List集合数据，这里似乎有点麻烦了，不过已经这样写了就这样举例吧。

public class Persons implements Parcelable {

    private List<Person> mList;

    Persons() {

    }

    Persons(Parcel in) {
        
        this.mList = new ArrayList<Person>();
       in.readTypedList(mList, Person.CREATOR);
    }

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        //
        dest.writeTypedList(mList);
    }
    
    public static final Parcelable.Creator<Persons> CREATOR = new Creator<Persons>() {
        
        @Override
        public Persons[] newArray(int size) {
            //
            return new Persons[size];
        }
        
        @Override
        public Persons createFromParcel(Parcel source) {
            //
            return new Persons(source);
        }
    };
    

    public List<Person> getmList() {
        return mList;
    }

    public void setmList(List<Person> mList) {
        this.mList = mList;
    }

}

Persons主要演示如何反序列化集合类数据，如11,12行代码。

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //
        Person p1 = new Person();
        p1.setAge(18);
        p1.setName("wanglei1");
        p1.setWeight(130);
        //
        Person p2 = new Person();
        p2.setAge(28);
        p2.setName("wanglei2");
        p2.setWeight(125);
        //
        List<Person> mList = new ArrayList<Person>();
       mList.add(p1);
       mList.add(p2);
        //
        Persons mPersons = new Persons();
        mPersons.setmList(mList);
        //
        Intent i = new Intent(this, SecondActivity.class);
        i.putExtra("persons", mPersons);
        startActivity(i);
        
    }
}



public class SecondActivity extends Activity {

    private static final String TAG = "WL";

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

        Intent intent = getIntent();
        Persons ps = (Persons) intent.getParcelableExtra("persons");
        List<Person> pList = ps.getmList();
        for (int i = 0; i < pList.size(); i++) {
            Person p = pList.get(i);
            Log.i(TAG, "age = " + p.getAge());
            Log.i(TAG, "name = " + p.getName());
            Log.i(TAG, "weight = " + p.getWeight());
        }

    }
}

主要就是通过intent.getParcelableExtra获取序列化的对象，也很简单。运行程序结果如下：

数据传递成功，如果仔细看上面例子应该对Parcelable方式实现序列化有了一定的了解，貌似写起来会比Serializable方式复杂一些，很多都是模板代码，照着写就是了。

另外，使用Parcelable接口进行bean对象序列化时，如果存在继承关系，可能要留意这个问题