使用Parcelable代替序列化对象的好处

Question

据我所知，Bundle和Parcelable属于安卓执行序列化的方式。例如，它用于在活动之间传递数据。但是我想知道，在将业务对象的状态保存到内部存储器的情况下，使用Parcelable而不是传统的序列化是否有任何好处？它会比经典的方式更简单还是更快？我应该在哪里使用经典序列化，在哪里更好地使用包？

Answer 1

摘自“安卓2”

注意:看到可打包可能会引发问题，为什么安卓不使用内置的Java序列化机制？事实证明，Android团队得出的结论是，Java中的序列化太慢了，无法满足Android的进程间通信需求。因此，团队构建了Parcelable解决方案。Parcelable方法要求您显式地序列化类的成员，但最终，您将获得更快的对象序列化。还要认识到Android提供了两种机制，允许您将数据传递给另一个进程。第一种方法是使用意图将包传递给活动，第二种方法是将Parcelable传递给服务。这两种机制不可互换，不应混淆。也就是说，Parcelable并不意味着要传递给activity。如果您想启动一个活动并向其传递一些数据，请使用捆绑包。Parcelable只能作为AIDL定义的一部分使用。

Answer 2

Serializable在安卓系统上的运行速度慢得可笑。事实上，在许多情况下，边界是无用的。

Parcel和Parcelable的速度非常快，但它的documentation表示，你不能将其用于通用的序列化到存储，因为不同版本的安卓的实现方式不同(即操作系统更新可能会破坏依赖它的应用程序)。

对于以合理的速度将数据序列化到存储中的问题，最好的解决方案是滚动您自己的数据。我个人使用我自己的一个实用程序类，它具有类似于Parcel的接口，并且可以非常有效地序列化所有标准类型(以牺牲类型安全性为代价)。这是它的一个删节版本：

public interface Packageable {
    public void readFromPackage(PackageInputStream in)  throws IOException ;
    public void writeToPackage(PackageOutputStream out)  throws IOException ; 
}


public final class PackageInputStream {

    private DataInputStream input;

    public PackageInputStream(InputStream in) {
        input = new DataInputStream(new BufferedInputStream(in));
    }

    public void close() throws IOException {
        if (input != null) {
            input.close();
            input = null;
        }       
    }

    // Primitives
    public final int readInt() throws IOException {
        return input.readInt();
    }
    public final long readLong() throws IOException {
        return input.readLong();
    }
    public final long[] readLongArray() throws IOException {
        int c = input.readInt();
        if (c == -1) {
            return null;
        }
        long[] a = new long[c];
        for (int i=0 ; i<c ; i++) {
            a[i] = input.readLong();
        }
        return a;
    }

...

    public final String readString()  throws IOException {
        return input.readUTF();
    }
    public final <T extends Packageable> ArrayList<T> readPackageableList(Class<T> clazz) throws IOException {
        int N = readInt();
        if (N == -1) {
            return null;
        }
        ArrayList<T> list = new ArrayList<T>();
        while (N>0) {
            try {
                T item = (T) clazz.newInstance();
                item.readFromPackage(this);
                list.add(item);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            N--;
        }
        return list;
    }

}



public final class PackageOutputStream {

    private DataOutputStream output;

    public PackageOutputStream(OutputStream out) {
        output = new DataOutputStream(new BufferedOutputStream(out));
    }

    public void close() throws IOException {
        if (output != null) {
            output.close();
            output = null;
        }
    }

    // Primitives
    public final void writeInt(int val) throws IOException {
        output.writeInt(val);
    }
    public final void writeLong(long val) throws IOException {
        output.writeLong(val);
    }
    public final void writeLongArray(long[] val) throws IOException {
        if (val == null) {
            writeInt(-1);
            return;
        }
        writeInt(val.length);
        for (int i=0 ; i<val.length ; i++) {
            output.writeLong(val[i]);
        }
    }

    public final void writeFloat(float val) throws IOException {
        output.writeFloat(val);
    }
    public final void writeDouble(double val) throws IOException {
        output.writeDouble(val);
    }
    public final void writeString(String val) throws IOException {
        if (val == null) {
            output.writeUTF("");
            return;
        }
        output.writeUTF(val);
    }

    public final <T extends Packageable> void writePackageableList(ArrayList<T> val) throws IOException {
        if (val == null) {
            writeInt(-1);
            return;
        }
        int N = val.size();
        int i=0;
        writeInt(N);
        while (i < N) {
            Packageable item = val.get(i);
            item.writeToPackage(this);
            i++;
        }
    }

}

Answer 3

看看比Serializable有多快。

​

​

来自WHY WE LOVE PARCELABLE

​

​

来自Parcelable vs Serializable