(Java) Especifique el número de bits (longitud) al convertir un número binario en una cadena?

Question

Estoy tratando de almacenar un número como una cadena binaria en una matriz, pero necesito especificar cuántos bits almacenar.

Por ejemplo, si necesito almacenar 0 con dos bits, necesito una cadena "00". O 1010 con 6 bits para "001010".

¿Alguien puede ayudar?

EDIT: Gracias chicos, como soy un tonto en matemáticas/programación en general, he ido con la solución más simple que era la de David. Algo así como:

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

Parece que funciona bien, así que a menos que sea muy ineficiente voy a ir con eso.

Answer 1

Uso Integer.toBinaryString() a continuación, comprobar la longitud de cadena y anteponga tantos ceros como sea necesario para hacer que su longitud deseada.

Answer 2

Olvídate de las soluciones caseras. Use el estándar BigInteger en su lugar. Puede especificar el número de bits y luego usar el método toString (int radix) para recuperar lo que necesita (supongo que necesita radix = 2).

EDIT: Dejaría el control de bits a BigInteger. El objeto cambiará el tamaño interno de su memoria intermedia de bits para que se ajuste a la nueva dimensión numérica. Además, las operaciones aritméticas se pueden llevar a cabo por medio de este objeto (no es necesario implementar sumadores binarios/multiplicadores, etc.). Aquí está un ejemplo 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 es un problema de tarea común. Hay un bucle genial que puede escribir que calculará la potencia más pequeña de 2> = su número de objetivo n.

Dado que es una potencia de 2, el logaritmo de la base 2 es el número de bits. Pero la biblioteca Java math solo ofrece el logaritmo natural.

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

es la cantidad de bits.

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

Salida:

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

Answer 5

Aquí hay una solución simple para int valores; debería ser obvio cómo extenderlo a, p. 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); 
} 

Aquí es el resultado de un conjunto de casos de prueba de muestra:

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 

Por supuesto, usted está en su propia para hacer que el parámetro de longitud adecuada para representar la totalidad del valor .

Answer 6

aún más simple:

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

La idea aquí es analizar la cadena de vuelta en como un número decimal temporal (uno que sólo da la circunstancia constará de todos de 1 y 0) y luego usar String.Format ()

Tenga en cuenta que básicamente tiene que usar BigInteger, porque las cadenas binarias se desbordan rápidamente Entero y Largo dando como resultado NumberFormatExceptions si intenta utilizar Integer.fromString() o Long.fromString().

Answer 7

Prueba esto:

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

donde el tamaño puede ser cualquier número que el usuario quiere

Answer 8

Así que aquí en lugar de 8 usted puede escribir su longitud deseada y se anexará ceros en consecuencia. Si la longitud de su número entero mencionado supera la del número mencionado entonces no va a añadir los ceros

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

de salida: 00001111

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

de salida: 1111