(Java) Especifique o número de bits (comprimento) ao converter número binário em seqüência?

Question

Eu estou tentando armazenar um número como uma string binária em uma matriz, mas eu preciso especificar quantos bits para armazená-lo como.

Por exemplo, se eu preciso para armazenar 0 com dois bits eu preciso de uma string "00". Ou 1.010 com 6 bits por isso "001010".

alguém pode ajudar?

EDIT: Obrigado rapazes, como eu sou lixo em matemática / programação em geral eu tenho ido com a solução mais simples que era Davi. Algo como:

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

Parece funcionar bem, por isso, a menos que seja muito ineficiente eu vou com ele.

Answer 1

Use Integer.toBinaryString() em seguida, verificar o comprimento da corda e preceder-lo com tantos zeros que você precisa fazer o seu comprimento desejado.

Answer 2

Esqueça soluções caseiras. Use padrão BigInteger . Você pode especificar o número de bits e, em seguida, usar (int radix) Método toString para recuperar o que você precisa (I supor que você precisa base = 2).

EDIT: eu deixaria de controle pouco para BigInteger. O objeto será redimensionada internamente seu buffer pouco para se ajustar à nova dimensão número. Além disso operações aritméticas podem ser realizadas por meio deste objeto (você não tem que implementar binários somadores / multiplicadores etc.). Aqui está um exemplo básico:

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

Este é um problema lição de casa comum. Há um laço legal que você pode escrever que irá calcular a menor potência de 2> = seu número de destino n .

Uma vez que é uma potência de 2, o logaritmo de base 2 é o número de bits. Mas a biblioteca math Java só oferece logaritmo natural.

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

é o número de bits.

Answer 4

Ainda mais simples:

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

A idéia aqui é para analisar a volta corda como um número decimal temporariamente (que só acontece a consistem em todos os 1 e 0) e, em seguida, usar String.format ().

Note que você basicamente tem que usar BigInteger, porque cadeias binárias rapidamente estouro Integer e Long resultando em NumberFormatExceptions se você tentar usar Integer.fromString() ou Long.fromString().

Answer 5

Tente isto:

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

onde o tamanho pode ser qualquer número que o usuário deseja

Answer 6

Aqui está uma solução simples para valores int; deveria ser óbvio como estendê-lo para, por exemplo, byte, etc.

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

Aqui está a saída de um conjunto de casos de teste de amostra:

  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

Claro, você está no seu próprio para tornar o comprimento parâmetro adequado para representar o valor inteiro.

Answer 7

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

Output:

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

Answer 8

Então, aqui em vez de 8 você pode escrever seu comprimento desejado e vai acrescentar zeros em conformidade. Se o comprimento do seu inteiro mencionado excede o do número mencionado, então não vai Acrescente qualquer zeros

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

Saída: 00001111

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

saída: 1111