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

Question

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

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

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

РЕДАКТИРОВАТЬ: Спасибо, ребята, так как я чушь в математике / программировании в целом, я пошел с самым простым решением, которое было Дэвид Что-то вроде:

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

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

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

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

Answer 5

Еще проще:

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 6

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

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

Выход: 00001111

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

Выход: 1111

Answer 7

Вот простое решение для 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 8

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