如何在活動之間傳遞雙數組（布爾[] []）？

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; 
} 

}