Question

我正在尝试将整数转换为7位布尔二进制数组。到目前为止代码不起作用：如果我输入要转换的整数8，而不是0001000，我得到1000000，或者说15我应该得到0001111但我得到1111000.字符数组与二进制数组的长度不同，位置错误。

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

实际上没有必要为此处理字符串，只需对您感兴趣的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 2

我会用这个：

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

带有基数7的数字15将产生{false，false，false，true，true，true，true} = 0001111b

8号，基数7 {false，false，false，true，false，false，false} = 0001000b

Answer 3

如果是System.out.println(maxAmpStr);，那么你得到的是“1000”。所以，你只得到相关的部分，你想要的第一个“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

提示：想想当你得到一个少于七个字符的字符表示时会发生什么。

特别要考虑char[]和boolean[]数组如何排列“;一个比另一个要多，所以指数应该如何重合？

实际答案：目前你正在使用字符数组的第一个元素作为布尔数组的第一个元素，这只在你使用七个字符的字符串时才是正确的。实际上，您希望数组的 last 元素重合（以便在前面填充零而不是在末尾）。

解决这个问题的一种方法是使用循环中的索引（例如，计算出大小差异并修改binaryarray[i + offset]）。但是更简单的解决方案就是在第一行之后用零填充字符串，以确保它在将其转换为char数组之前正好是七个字符。

（额外标记：当数组中有超过7个字符时你会怎么做，例如，如果某人以200作为参数传递？基于上述两种解决方案，您应该能够轻松地检测到这种情况，特别处理它。）

Answer 5

由于此处没有人有动态数组长度的答案，这是我的解决方案：

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

Answer 6

char数组只是需要的时间，所以你的布尔数组可能会更长，并将位置放在错误的位置。所以从后面开始，当你的char数组完成后，用0'填充你的布尔数组直到第一个位置。

Answer 7

Integer.toBinaryString(int i)没有填充。对于例如Integer.toBinaryString(7)按预期打印111而不是00000111。在决定从哪里开始填充布尔数组时，需要考虑到这一点。

Answer 8

15.ToBinaryString将为'1111'

你是从第一个字符到最后一个字符，所以第一个'1'是bit（3）进入binaryArray [0]，我假设它应该是0位。

你需要用前导零填充ToBinaryString，长度为7（8 ??）然后反转字符串，（或你的循环）

或者你可以停止使用字符串搞乱，只使用位操作符

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

^ =幂运算符，如果不是（1 <＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt;＆lt; 3＆gt

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

    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
将该值附加到字符串
做无符号右移对于i = 30..0

Answer 11

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

整数到二进制数组

11 个答案: