(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 para almacenarlo.

Por ejemplo, si necesito almacenar 0 con dos bits, necesito una cadena " 00 " ;. O 1010 con 6 bits, por lo que " 001010 " ;.

¿Alguien puede ayudar?

EDITAR: Gracias chicos, ya que soy una basura en matemáticas / programación en general, he optado por la solución más simple que fue la de David. Algo 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, lo haré.

Answer 1

Use Integer.toBinaryString () luego verifique la longitud de la cadena y prepárela con tantos ceros como sea necesario para hacer la longitud deseada.

Answer 2

Olvídate de las soluciones caseras. Utilice 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).

EDITAR: dejaría el control de bits a BigInteger. El objeto redimensionará internamente su búfer de bits para ajustarse a la nueva dimensión numérica. Además, mediante este objeto se pueden realizar operaciones aritméticas (no es necesario implementar sumadores / multiplicadores binarios, etc.). Aquí hay 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 circuito genial que puedes escribir que calculará la potencia más pequeña de 2 > = tu número objetivo n .

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

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

es el número de bits.

Answer 4

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 nuevamente como un número decimal temporalmente (uno que por casualidad consiste en todos los 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 Integer y Long, lo que da como resultado NumberFormatExceptions si intenta usar Integer.fromString () o Long.fromString () .

Answer 5

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 quiera

Answer 6

Aquí hay una solución simple para los valores de int ; debería ser obvio cómo extenderlo a, por ejemplo, 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í está la salida 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, estás por tu cuenta para hacer que el parámetro de longitud sea el adecuado para representar el valor completo.

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

Salida:

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

Answer 8

Así que aquí, en lugar de 8, puedes escribir la longitud deseada y agregará ceros en consecuencia. Si la longitud del número entero mencionado supera la del número mencionado, no se agregarán ceros

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

  

Salida: 00001111

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

  

salida: 1111