Question

据我了解，Bundle和Parcelable属于Android执行序列化的方式。例如，它用于在活动之间传递数据。但我想知道，如果在将业务对象的状态保存到内部存储器的情况下使用Parcelable而不是经典序列化有什么好处？它会比传统方式更简单或更快吗？我应该在哪里使用经典序列化以及哪里更好地使用bundle？

Answer 1

来自“Pro Android 2”

注意：看到Parcelable可能触发了这个问题，为什么Android没有使用       内置的Java序列化机制？事实证明，   Android团队得出结论       Java中的序列化太慢而无法满足Android的要求   进程间通信       要求。因此团队构建了Parcelable解决方案。该   可行的方法需要       您明确序列化您的类的成员，但最后，   你得到更快       序列化您的对象。

还要意识到Android提供了两种允许您通过的机制   数据到另一个       处理。第一种是使用intent将包传递给活动，   第二是通过       可分配给服务。这两种机制不可互换   不应该是       困惑。也就是说，Parcelable并不意味着传递给   活动。如果你想开始       一个活动并传递一些数据，使用一个包。 Parcelable意为   仅作为一部分使用       AIDL定义。

Answer 2

在Android上，

Serializable显然很慢。事实上，在许多情况下，边界无用。

Parcel和Parcelable非常快，但documentation表示您不得将其用于存储的通用序列化，因为实施因Android的不同版本而异（即操作系统更新可能会破坏依赖它的应用程序。）

以合理的速度将数据序列化到存储的问题的最佳解决方案是自行推送。我个人使用我自己的一个实用程序类，它具有与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++;
        }
    }

}