Java 整数到二进制数组

我正在尝试将整数转换为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]);
}

publicstaticvoidmain（字符串[]args）{
字符串maxAmpStr=Integer.toBinaryString（8）；
char[]arr=maxAmpStr.toCharArray（）；
布尔[]二进制数组=新布尔[7]；
对于（int i=0；i字符数组的长度与需要的长度相同，因此您的布尔数组可能会更长，并将位放在错误的位置。因此，从后面开始，当您的字符数组完成时，在布尔数组中填充0，直到第一个位置。
提示：考虑当您得到小于se的字符表示时会发生什么情况维恩字符

特别是，考虑一下
char[]
和
boolean[]
数组如何“排列”；其中一个数组中会有额外的元素，那么索引应该如何重合呢


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

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

（额外标记：当数组中的字符数超过7个时，例如，如果有人将
200
作为参数传入，你会怎么做？基于上述两种解决方案，你应该能够轻松地检测到这种情况，并具体地处理它。）
当你执行
System.out.println（maxamptr）；
在8的情况下是“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;
    }
}

for（int i=0；i
Integer.toBinaryString（int i）
不填充。例如
Integer.toBinaryString（7）
打印的是
111
而不是您期望的
00000111
。在决定从何处开始填充布尔数组时，您需要考虑到这一点。
确实不需要处理字符串，只需对感兴趣的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));
}

publicstaticvoidmain（字符串[]args）{
int输入=15；
布尔[]位=新的布尔[7]；
对于（int i=6；i>=0；i--）{
位[i]=（输入和（115）。ToBinaryString将为“1111”

您正在从第一个字符到最后一个字符进行剪切，因此第一个“1”位（3）将进入二进制数组[0]，我假设它应该是位0

您必须使用前导零将ToBinarysting填充到长度为7（8°）
然后反转字符串（或循环）

或者，您可以停止乱搞字符串，只需使用位运算符

二进制数组[3]=（SomeInt&&2^3！=0）

^=功率运算符，如果不是（1我将使用：

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

private static boolean[]toBinary（整数，整数基）{
最终布尔值[]ret=新布尔值[base]；
for（int i=0；i数字加1
将值附加到字符串
做无符号右移
对于i=30..0，重复步骤1-3
String maxAmpStr=Integer.toBinaryString（255）；
char[]arr=maxAmpStr.toCharArray（）；
布尔[]二进制数组=新布尔[20]；
int pivot=binaryarray.length-arr.length；
int j=binaryarray.length-1；
对于（int i=arr.length-1；i>=0；i--）{
如果（arr[i]=“1”）{
二进制数组[j]=true；
}else if（arr[i]=“0”）{
二进制数组[j]=false；
}
如果（j>=枢轴）
j--；
}
系统输出打印LN（最大安培数）；
for（int k=0；k
因为这里没有人有动态数组长度的答案，所以下面是我的解决方案：

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

公共静态布尔[]转换二进制（整数）{
int=0；
int-bin=1；
而（bin=0）{
如果（B这是家庭作业吗？使用除法和余数除以2。您是否尝试过手动或使用调试器遍历代码？如果您使用
8
作为输入，这两者都不应该是一个挑战，并且会让您看到结果从何处开始偏离正确性。即使
tobinarysting
printed
00000111
，这也是一个挑战程序仍然是不正确的，因为索引仍然不会在char和boolean数组之间“对齐”（事实上，它会因IndexOutOfBoundsException而失败，尽管这可以很容易地修复，以留下根本问题）+1作为一个如此简洁的示例，但您的答案可能需要解释OP不起作用的原因。我对200+
位
感兴趣，所以这个解决方案不起作用。您能给出建议吗？有没有办法使用
布尔[]
（
位
）或者我应该试试
Strings
？如果您能进一步阐述代码片段的全部内容，这将有助于更好地理解未来的观众。这里使用
base
有点误导，因为二进制总是以2为基数。也许
length
更合适。事实上，您可以计算
长度
作为天花板底2对数
  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;
  }

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

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