如何在活动之间传递双数组（布尔[][]）？

Question

我看不到要让双布尔数组传递给另一个活动。我使用 putExtra，当我检索它并将其转换为 boolean[][] 时，它指出它不能转换并崩溃。但是 Boolean[] 有效。

如何在活动之间传递boolean[][]？

Answer 1

如果你绝对需要一个 boolean[][]（并且不能只使用一个平面 boolean[] 数组传递给 Parcel.writeBooleanArray()），那么正式的方法是将它包装在一个Parcelable 类并在那里进行编组/解组。

我会勾勒出代码，虽然这没有经过测试，所以肯定会有一些问题。

public class BooleanArrayArray implements Parcelable {
    private final boolean[][] mArray;

    public BooleanArrayArray(boolean[][] array) {
        mArray = array;
    }

    private BooleanArrayArray(Parcelable in) {
        boolean[][] array;
        final int N = in.readInt();
        array = new boolean[][N];
        for (int i=0; i<N; i++) {
            array[i] = in.createBooleanArray();
        }
        mArray = array;
    }

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

    @Override
    public void writeToParcel(Parcel out, int flags) {
        final int N = mArray.length;
        out.writeInt(N);
        for (int i=0; i<N; i++) {
            out.writeBooleanArray(mArray[i]);
        }
    }

    public static final Parcelable.Creator<BooleanArrayArray> CREATOR
            = new Parcelable.Creator<BooleanArrayArray>() {
        public BooleanArrayArraycreateFromParcel(Parcel in) {
            return new BooleanArrayArray(in);
        }

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

Answer 2

如果你真的需要一个二维数组，你可以轻松地将二维数组转换为一维数组，以便在活动之间传递，如下所示：

public boolean[] toOneDimension(boolean[][] input){
    boolean[] output = new boolean[input.length * input[0].length];

    for(int i = 0; i < input.length; i++){
        for(int j = 0; j < input[i].length; j++){
            output[i*j] = input[i][j];
        }
    }

    return output;
}

然后您可以将其重新构建为二维数组，如下所示：

public boolean[][] toTwoDimensions(int dimensions, boolean[] input){

    boolean[][] output = new boolean[input.length / dimensions][dimensions];

    for(int i = 0; i < input.length; i++){
        output[i/dimensions][i % dimensions] = input[i];
    }

    return output;
}

然后像这样使用：

public static void main(String[] args){
    int size = 10;

    Random rand = new Random();
    Tester tester = new Tester(); //example code holder
    boolean[][] value = new boolean[size+1][size];

    for(int i = 0; i < size+1; i++){
        for(int j = 0; j < size; j++){
            value[i][j] = rand.nextBoolean();
        }
    }


    boolean [][] output = tester.toTwoDimensions(size, tester.toOneDimension(value));

    for(int i = 0; i < size+1; i++){
        for(int j = 0; j < size; j++){
            assert value[i][j] == output[i][j];
        }
    }


}

唯一的要求是您需要在展平之前知道数组的维度。

Answer 3

这是旧的，但对我帮助很大，所以我想分享我的发现。 我使用Parcelabler 使我的对象类 Parcelable（因为我读到的所有内容都是用火星语写给我的），然后我使用@John Ericksen 答案在我的对象类中实现它，并使用一些方法让我的生活更轻松flattenMultiDimensionalArray和restoreMultiDimensionalArray 和最终结果。

对于二维数组

多维数组.java

public class MultiDimensionalArray implements Parcelable {

private int[][] multiDimensionalArray;
//Any other Variables, Objects

public MultiDimensionalArray() {

}

public MultiDimensionalArray(int[][] multiDimensionalArray) {

    this.multiDimensionalArray = multiDimensionalArray;
    //Any other Variables, Objects
}

public int[][] getMultiDimensionalArray() {

    return multiDimensionalArray;
}

public void setMultiDimensionalArray(int[][] multiDimensionalArray) {

    this.multiDimensionalArray = multiDimensionalArray;
}

protected MultiDimensionalArray(Parcel in) {

    int rows = in.readInt();
    int columns = in.readInt();
    int[] transitionalArray = in.createIntArray();
    multiDimensionalArray = restoreMultiDimensionalArray(transitionalArray, rows, columns);
    //Any other Variables, Objects

}

@Override
public int describeContents() {

    return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {

    int rows = multiDimensionalArray.length;
    int columns = multiDimensionalArray[rows - 1].length;
    int[] transitionalArray = flattenMultiDimensionalArray(multiDimensionalArray);
    dest.writeInt(rows);
    dest.writeInt(columns);
    dest.writeIntArray(transitionalArray);
    //Any other Variables, Objects

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

    @Override
    public MultiDimensionalArray createFromParcel(Parcel in) {

        return new MultiDimensionalArray(in);
    }

    @Override
    public MultiDimensionalArray[] newArray(int size) {

        return new MultiDimensionalArray[size];
    }
};
private int[] flattenMultiDimensionalArray(int[][] sourceCard) {

    int k = 0;
    int[] targetCard = new int[sourceCard.length * sourceCard[sourceCard.length - 1].length];
    for (int[] aSourceCard : sourceCard) {
        for (int anASourceCard : aSourceCard) {
            targetCard[k] = anASourceCard;
            k++;
        }
    }
    return targetCard;
}
private int[][] restoreMultiDimensionalArray(int[] sourceCard, int rows, int columns) {

    int k = 0;
    int[][] multiDimensionalArray = new int[rows][columns];
    for (int i = 0; i < multiDimensionalArray.length; i++) {
        for (int j = 0; j < multiDimensionalArray[multiDimensionalArray.length - 1].length; j++) {
            multiDimensionalArray[i][j] = sourceCard[k];
            k++;
        }
    }
    return multiDimensionalArray;
}

}