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

Question

我看不到得到一个双布尔数组传递给另一个活动。我使用putExtra，当我检索它并将其转换为boolean[][]时，它指出它不能投射并崩溃。然而，布尔[]工作。

我该怎么办在活动之间通过boolean[][]？

Answer 1

如果你绝对需要一个布尔[] []（并不能做到这一点，只需平布尔[]数组传递给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 class myActivity extends Activity 
{ 

    private static boolean[][] myBooleanVar; 
    .... 
    .... 
    .... 

    public static boolean[][] getBooleanArray() 
    { 
     return myBooleanVar; 
    } 
} 

Answer 3

如果你真的需要一个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; 
} 

然后你就可以建立回一个2维阵列像这样：

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 4

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

对于一个2维数组

MultiDimensionalArray的.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; 
} 

}