Android:Serializable和Parcelable的持久化保存

转自：https://www.cnblogs.com/duoshou/articles/8856111.html

前言:

Serializable和Parcelable能够将对象序列化，使之能够在一些特殊场景中进行传输，再进行数据的恢复(Serializable是Java实现的接口，而Parcelable是Android实现的)。

两者作用类似但是实现等其他方面有较大区别，比较多的说法认为Parcelable不适合用于数据的持久化保存，但合适与否和是否可行完全是两码事(GSON是另外一种保存对象的方式)。

出于好奇想从性能方面比较两者持久化的异同。

 

一.Serializable

需要实现的类如下

class SerialData implements Serializable {

    private static final long serialVersionUID = -7060210544622464481L;

    public ArrayList<String> array;

    public SerialData() {
        array = new ArrayList<String>();
        for (int i = 0; i < 100000; i++) {
            array.add(new String("123"));
        }
    }
}

写方法

private void saveAsSerializable(SerialData data) {
        FileOutputStream fos;
        ObjectOutputStream oos;
        try {
            fos = getApplicationContext().openFileOutput(TAG,
                    Context.MODE_PRIVATE);
            oos = new ObjectOutputStream(fos);
            oos.writeObject(data);
            oos.close();
            fos.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

读方法

private SerialData readData() {
        SerialData obj = null;
        FileInputStream fis;
        ObjectInputStream ois;
        try {
            fis = getApplicationContext().openFileInput(TAG);
            ois = new ObjectInputStream(fis);
            obj = (SerialData) ois.readObject();
            ois.close();
            fis.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        if (obj != null)
            return obj;
        else
            return null;

    }

二.Parcelable

实现类

class ParceData implements Parcelable {
    public ArrayList<String> array;

    public ParceData() {
        array = new ArrayList<String>();
        for (int i = 0; i < 100000; i++) {
            array.add(new String("123"));
        }
    }

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

    @Override
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeStringList(array);
    }

    public static final Parcelable.Creator<ParceData> CREATOR = new Creator<ParceData>() {
        @Override
        public ParceData[] newArray(int size) {
            return new ParceData[size];
        }

        @Override
        public ParceData createFromParcel(Parcel in) {
            return new ParceData(in);
        }
    };

    public ParceData(Parcel in) {
        array = new ArrayList<String>();
        in.readStringList(array);
    }
}

写方法

protected void saveParce() {
        FileOutputStream fos;
        try {
            fos = getApplicationContext().openFileOutput(TAG,
                    Context.MODE_PRIVATE);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            Parcel parcel = Parcel.obtain();
            parcel.writeParcelable(new ParceData(), 0);

            bos.write(parcel.marshall());
            bos.flush();
            bos.close();
            fos.flush();
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

读方法

protected void loadParce() {
        FileInputStream fis;
        try {
            fis = getApplicationContext().openFileInput(TAG);
            byte[] bytes = new byte[fis.available()];
            fis.read(bytes);
            Parcel parcel = Parcel.obtain();
            parcel.unmarshall(bytes, 0, bytes.length);
            parcel.setDataPosition(0);

            ParceData data = parcel.readParcelable(ParceData.class.getClassLoader());
            fis.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

三.速度比较

1.Serializable

执行如下操作:

SerialData data = new SerialData();
Log.e("time", "befor = " + System.currentTimeMillis());
saveAsSerializable(data);
Log.e("time", "after = " + System.currentTimeMillis());

10次平均:2889ms

 

2.Parcelable

操作如下:

Log.e("time", "befor = " + System.currentTimeMillis());
saveParce();
Log.e("time", "after = " + System.currentTimeMillis());

 

10次平均:360ms

 

四.内存比较

初始状态:

 

 

执行一次Serializable的写入

执行一次Parcelable的写入

 

 

 

Pacelable在速度上，内存的使用上都比Serializable有优势。虽然如此，实际上面的数据并没有太大的参考意义，两个类都创建了10万个对象，项目中这种情况很少遇到。

实现起来Serializable更简单，实现接口即可，而Pacelable作二进制的转化，对写入和读取的顺序都要保持一致，对象越多实现越复杂。