Question

我有这个：

public double[][] mRoute;

我需要Parcelable，但我不确定最好的方法。

似乎将它变成List，然后写出这不是正确的方法。

更新

这是根据@ yuku的回答编写的。

    out.writeInt(mRoute.length); // store the length
    for (int i = 0; i < mRoute.length; i++) {
        out.writeInt(mRoute[i].length);
        out.writeDoubleArray(mRoute[i]);
    }
    mRoute = new double[in.readInt()][]; 
    for (int i = 0; i < mRoute.length; i++) {
         mRoute[i] = new double[in.readInt()];
         in.readDoubleArray(mRoute[i]);
    }

我还没有尝试过，只是让它编译，这是一个开始。

Answer 1

你不能使double [] []成为Parcelable，但你可以创建一个实现Parcelable的类并包含double [] []。

在writeToParcel（Parcel dest）上，执行：

dest.writeInt(mRoute.length); // store the length
for (int i = 0; i < mRoute.length; i++) {
    dest.writeDoubleArray(mRoute[i]);
}

在readFromParcel（Parcel in）上，执行：

mRoute = new double[][in.readInt()]; 
for (int i = 0; i < mRoute.length; i++) {
    mRoute[i] = in.readDoubleArray();
}

Answer 2

我自己从未使用过Parcelable，但在阅读了JavaDoc后，我认为这通常会有效：

创建一个包裹Foo implements Parcelable的班级double[]，以便您可以使用
Parcel #[ create | write ]doubleArray()，然后
创建一个包裹Bar implements Parcelable的班级Foo[]，以便您可以使用
Parcel #[ create | write ]TypedArray()

_{（对不起，评论有点长，如果它没用，我很乐意删除。）}

像这样（编译但未经过测试，没有@Overrides，警告经纪人和whot）：

public class Foo implements Parcelable {
    private double[] mData;

    // Not really sure what bitmask to use for a double[]...
    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel out, int flags) {
        out.writeDoubleArray(mData);
    }

    public static final Creator<Foo> CREATOR = new Creator<Foo>() {

        public Foo createFromParcel(Parcel in) {
            return new Foo(in);
        }

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

    private Foo(Parcel in) {
        mData = in.createDoubleArray();
    }
}

和

public class Bar implements Parcelable {
    private Foo[] mData;

    // Same as above
    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel out, int flags) {
        out.writeTypedArray(mData, 0);
    }

    public static final Creator<Bar> CREATOR = new Creator<Bar>() {

        public Bar createFromParcel(Parcel in) {
            return new Bar(in);
        }

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

    private Bar(Parcel in) {
        mData = in.createTypedArray(Foo.CREATOR);
    }
}

如何将double [] []转换为parcelable

2 个答案: