整數到二進制數組

Question

我想將整數轉換爲7位布爾二進制數組。到目前爲止的代碼不工作： 如果我輸入說整數8要轉換，而不是0001000我得到1000000，或說15我應該得到0001111，但我得到1111000.該char數組是不同的長度二進制數組和立場是錯誤的。

public static void main(String[] args){ 

    String maxAmpStr = Integer.toBinaryString(8); 
    char[] arr = maxAmpStr.toCharArray(); 
    boolean[] binaryarray = new boolean[7]; 
    for (int i=0; i<maxAmpStr.length(); i++){ 
     if (arr[i] == '1'){    
      binaryarray[i] = true; 
     } 
     else if (arr[i] == '0'){ 
      binaryarray[i] = false; 
     } 
    } 

    System.out.println(maxAmpStr); 
    System.out.println(binaryarray[0]); 
    System.out.println(binaryarray[1]); 
    System.out.println(binaryarray[2]); 
    System.out.println(binaryarray[3]); 
    System.out.println(binaryarray[4]); 
    System.out.println(binaryarray[5]); 
    System.out.println(binaryarray[6]); 
} 

任何幫助表示讚賞。

Answer 1

char-array只有需要的時間長，所以你的布爾數組可能會更長，並將位放在錯誤的位置。所以從後面開始，當你的char數組完成時，用0填充你的布爾數組，直到第一個位置。

Answer 2

提示：想想當你得到少於7個字符的字符表示時會發生什麼。

特別是，請考慮char[]和boolean[]陣列是如何「排隊」的;一個會比另一個多一些，所以這些指數應該如何重合？

---

實際答案：目前您正在使用的字符數組的布爾數組，當您使用的是七字符串這是唯一正確的第一個元素的第一個元素。實際上，你希望數組的元素重合（使得零的前面不是末尾填充）。

解決此問題的一種方法是使用循環中的索引（例如，計算大小差異並改爲修改binaryarray[i + offset]）。但更簡單的解決方案就是在第一行之後用零填充字符串，以確保在將其轉換爲char數組之前，它只有7個字符。

（額外的標誌：當數組中有7個以上的字符時，你會怎麼做，例如，如果有人通過200作爲參數？基於上述兩種解決方案，您應該能夠輕鬆檢測到這種情況並專門處理它）

Answer 3

當你做什麼時你會得到System.out.println(maxAmpStr);是「1000」，如果是8.0 所以，你只會得到相關部分，你所期望的第一個「0000」就被省略了。

它不漂亮，但你可以做的是：

for (int i=0; i<maxAmpStr.length(); i++) 
{ 
    if (arr[i] == '1') 
    { 
     binaryarray[i+maxAmpStr.length()-1] = true; 
    } 
    else if (arr[i] == '0') 
    { 
     binaryarray[i+maxAmpStr.length()-1] = false; 
    } 
} 

Answer 4

Integer.toBinaryString(int i)不墊。對於例如Integer.toBinaryString(7)打印111不像您期望的00000111。在決定從何處開始填充布爾數組時，需要考慮到這一點。

Answer 5

真的沒有必要處理這個字符串，只是做按位比較的7位你感興趣的內容。

public static void main(String[] args) { 

    int input = 15; 

    boolean[] bits = new boolean[7]; 
    for (int i = 6; i >= 0; i--) { 
     bits[i] = (input & (1 << i)) != 0; 
    } 

    System.out.println(input + " = " + Arrays.toString(bits)); 
} 

Answer 6

15.ToBinaryString將「1111」

你是從第一個字符到最後一個字符，所以位（3）的第一個'1'進入binaryArray [0]，我認爲它應該是位0。

您定義墊ToBinaryString前導零至7（8？） 然後長度字符串逆向（或你的循環）

或者你可以停止擺弄字符串和簡單的使用位明智的運營商

BinaryArray [3] =（SomeInt & & 2^3！= 0）;

^=電力運營商或如果沒有（1 < < 3）或任何Java中的左移。

Answer 7

我會使用這樣的：

private static boolean[] toBinary(int number, int base) { 
    final boolean[] ret = new boolean[base]; 
    for (int i = 0; i < base; i++) { 
     ret[base - 1 - i] = (1 << i & number) != 0; 
    } 
    return ret; 
} 

號15與底座7會產生{FALSE，FALSE，FALSE，TRUE，真實，真實的，真} = 0001111b

數8，基部7 { FALSE，FALSE，FALSE，TRUE，FALSE，FALSE，FALSE} = 0001000b

Answer 8

public static String intToBinary(int num) { 
    int copy = num; 
    String sb = ""; 
    for(int i=30; i>=0; i--) { 
     sb = (copy&1) + sb; 
     copy = copy >>>=1; 
    } 
    return sb; 
} 

1. 並用數字1
2. 追加谷爲字符串
3. 做無符號右移 重複步驟1-3，對於i = 30..0

Answer 9

public static boolean[] convertToBinary(int b){ 
    boolean[] binArray = new boolean[7]; 
    boolean bin; 
    for(int i = 6; i >= 0; i--) { 
     if (b%2 == 1) bin = true; 
     else bin = false; 
     binArray[i] = bin; 
     b/=2; 
    } 
    return binArray; 
    } 

Answer 10

String maxAmpStr = Integer.toBinaryString(255); 
    char[] arr = maxAmpStr.toCharArray(); 
    boolean[] binaryarray = new boolean[20]; 
    int pivot = binaryarray.length - arr.length; 
    int j = binaryarray.length - 1; 
    for (int i = arr.length - 1; i >= 0; i--) { 
     if (arr[i] == '1') { 
      binaryarray[j] = true; 
     } else if (arr[i] == '0') { 
      binaryarray[j] = false; 
     } 
     if (j >= pivot) 
      j--; 
    } 

    System.out.println(maxAmpStr); 
    for (int k = 0; k < binaryarray.length; k++) 
     System.out.println(binaryarray[k]); 
} 

Answer 11

由於這裏沒有人具有帶動態數組一個答案長度，這裏是我的解決方案：

public static boolean[] convertToBinary(int number) { 
    int binExpo = 0; 
    int bin = 1; 
    while(bin < number) { //calculates the needed digits 
     bin = bin*2; 
     binExpo++; 
    } 
    bin = bin/2; 
    boolean[] binary = new boolean[binExpo]; //array with the right length 
    binExpo--; 
    while(binExpo>=0) { 
     if(bin<=number) { 
      binary[binExpo] = true; 
      number =number -bin; 
      bin = bin/2; 
     }else { 
      binary[binExpo] = false; 
     } 
     binExpo--; 
    } 
    return binary; 
}