(Java) Укажите количество бит (длина) при преобразовании двоичного числа в строку?

Question

Я пытаюсь сохранить число в виде двоичной строки в массиве, но мне нужно указать, сколько бит будет хранить его как.

Например, если мне нужно хранить 0 с двумя битами, мне нужна строка «00». Или 1010 с 6 бит так «001010».

Может ли кто-нибудь помочь?

EDIT: Спасибо, ребята, поскольку я мусор по математике/программированию в целом, я пошел с простейшим решением, которое было Дэвидом. Что-то вроде:

binaryString.append(Integer.toBinaryString(binaryNumber)); 
for(int n=binaryString.length(); n<numberOfBits; n++) { 
         binaryString.insert(0, "0"); 
} 

Кажется, что все нормально, поэтому, если это не очень эффективно, я пойду с ним.

Answer 1

Используйте Integer.toBinaryString() затем проверить длину строки и предварять его с таким количеством нулей, как вам нужно, чтобы сделать нужную длину.

Answer 2

Забудьте о домашних решениях. Вместо этого используйте стандарт BigInteger. Вы можете указать количество бит, а затем использовать метод toString (int radix) для восстановления того, что вам нужно (я предполагаю, что вам нужен radix = 2).

EDIT: Я бы оставил бит-контроль до BigInteger. Объект будет внутренне изменять размер битового буфера, чтобы он соответствовал новому размеру. Кроме того, арифметические операции могут выполняться с помощью этого объекта (вам не нужно реализовывать двоичные сумматоры/множители и т. Д.). Вот простой пример:

package test; 

import java.math.BigInteger; 

public class TestBigInteger 
{ 
    public static void main(String[] args) 
    { 
     String value = "1010"; 
     BigInteger bi = new BigInteger(value,2); 
     // Arithmetic operations 
     System.out.println("Output: " + bi.toString(2)); 
     bi = bi.add(bi); // 10 + 10 
     System.out.println("Output: " + bi.toString(2)); 
     bi = bi.multiply(bi); // 20 * 20 
     System.out.println("Output: " + bi.toString(2)); 

     /* 
     * Padded to the next event number of bits 
     */ 
     System.out.println("Padded Output: " + pad(bi.toString(2), bi.bitLength() + bi.bitLength() % 2)); 
    } 

    static String pad(String s, int numDigits) 
    { 
     StringBuffer sb = new StringBuffer(s); 
     int numZeros = numDigits - s.length(); 
     while(numZeros-- > 0) { 
      sb.insert(0, "0"); 
     } 
     return sb.toString(); 
    } 
} 

Answer 3

Это обычная домашняя проблема. Есть крутой цикл, который вы можете написать, который будет вычислять наименьшую мощность 2> = ваш целевой номер n.

Поскольку это мощность 2, логарифм базы 2 - это количество бит. Но библиотека Java math предлагает только натуральный логарифм.

math.log(n)/math.log(2.0) 

- количество бит.

Answer 4

import java.util.BitSet; 

public class StringifyByte { 

    public static void main(String[] args) { 
     byte myByte = (byte) 0x00; 
     int length = 2; 
     System.out.println("myByte: 0x" + String.valueOf(myByte)); 
     System.out.println("bitString: " + stringifyByte(myByte, length)); 

     myByte = (byte) 0x0a; 
     length = 6; 
     System.out.println("myByte: 0x" + String.valueOf(myByte)); 
     System.out.println("bitString: " + stringifyByte(myByte, length)); 
    } 

    public static String stringifyByte(byte b, int len) { 
     StringBuffer bitStr = new StringBuffer(len); 
     BitSet bits = new BitSet(len); 
     for (int i = 0; i < len; i++) 
     { 
      bits.set (i, (b & 1) == 1); 
      if (bits.get(i)) bitStr.append("1"); else bitStr.append("0"); 
      b >>= 1; 
     } 
     return reverseIt(bitStr.toString()); 
    } 

    public static String reverseIt(String source) { 
     int i, len = source.length(); 
     StringBuffer dest = new StringBuffer(len); 

     for (i = (len - 1); i >= 0; i--) 
      dest.append(source.charAt(i)); 
     return dest.toString(); 
    } 
} 

Выход:

myByte: 0x0 
bitString: 00 
myByte: 0x10 
bitString: 001010 

Answer 5

Вот простое решение для int значений; должно быть очевидно, как расширить его до, например, байт и т.д.

public static String bitString(int i, int len) { 
    len = Math.min(32, Math.max(len, 1)); 
    char[] cs = new char[len]; 
    for (int j = len - 1, b = 1; 0 <= j; --j, b <<= 1) { 
     cs[j] = ((i & b) == 0) ? '0' : '1'; 
    } 
    return new String(cs); 
} 

Вот выход из набора тестовых образцов:

0 1        0        0 
    0 -1        0        0 
    0 40 00000000000000000000000000000000 00000000000000000000000000000000 
13 1        1        1 
13 2        01        01 
13 3        101        101 
13 4        1101        1101 
13 5       01101       01101 
-13 1        1        1 
-13 2        11        11 
-13 3        011        011 
-13 4        0011        0011 
-13 5       10011       10011 
-13 -1        1        1 
-13 40 11111111111111111111111111110011 11111111111111111111111111110011 

Конечно, вы можете самостоятельно сделать параметр длины достаточно, чтобы представить всю стоимость ,

Answer 6

Еще проще:

String binAddr = Integer.toBinaryString(Integer.parseInt(hexAddr, 16)); 
String.format("%032", new BigInteger(binAddr)); 

Идея заключается в том, чтобы разобрать строку обратно в виде десятичного числа временно (тот, который просто так случается, состоит из всех 1 и 0), а затем использовать string.Format ().

Обратите внимание, что в основном вы должны использовать BigInteger, потому что бинарные строки быстро переполняют Integer и Long, приводя к NumberFormatExceptions, если вы пытаетесь использовать Integer.fromString() или Long.fromString().

Answer 7

Попробуйте это:

String binaryString = String.format("%"+Integer.toString(size)+"s",Integer.toBinaryString(19)).replace(" ","0"); 

где размер может быть любое число пользователь хочет

Answer 8

Так вот вместо 8 вы можете написать нужную длину, и он будет добавлять нули соответственно. Если длина вашего упомянутого целого превышает число упоминается, то он не будет добавлять любые нули

String.format("%08d",1111);

Выход: 00001111

String.format("%02d",1111); 

выход: 1111