Estoy tratando de almacenar un número como una cadena binaria en un array, pero debo especificar el número de bits para guardarlo como.

Por ejemplo, si voy a la tienda a 0 con dos bits necesito una cadena de «00». O 1010 con 6 bits por lo que «001010».

Alguien puede ayudar?

EDIT: Gracias chicos, ya estoy de basura en matemáticas/programación en general me 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, por lo menos es muy ineficiente voy a ir con ella.

Que no funciona con los números negativos y los números mayores que 2^31, ya que no caben dentro de un Java Entero. BigInteger ajusta automáticamente el número de bits que se utiliza para almacenar el valor. Todavía puede utilizar su relleno método para insertar 0 por delante.
Lo siento, yo no sabía nada de la marca aceptado cosa. Gracias por el heads up de Fernando, pero no creo que voy a tener que hacer esto para los números negativos o algo mayor que 2^16 por lo que este debe estar bien, supongo. Voy a echar un vistazo a BigInteger sólo en el caso de todos modos.

OriginalEl autor joinJpegs | 2009-03-09

8 Comentarios

  1. 10

    Uso Integer.toBinaryString(), a continuación, compruebe la longitud de la cadena y anteponer con tantos ceros como usted necesita para hacer de su longitud deseada.

    De la cadena.format(«%08d», Entero.valueOf(Integer.toBinaryString(my_integer)))
    Sé que esto es una respuesta tardía, pero vale la pena señalar que la «sugerencia» @Logic1 dio puede causar problemas. Si usted tiene un gran número entero, esto provocará un desbordamiento, y dar resultados inesperados. El one-liner voy con: Cadena.format(«%32s», Entero.toBinaryString(flagValue.getIntValue())).replace(‘ ‘, ‘0’)

    OriginalEl autor David Z

  2. 4

    Olvidarse de hogar soluciones. Utilizar el estándar de BigInteger lugar. Se puede especificar el número de bits y, a continuación, utilizar toString(int base) método para recuperar lo que usted necesita (yo asumo que usted necesita radix=2).

    EDICIÓN: yo dejaría el control poco a BigInteger. El objeto internamente cambiar el tamaño de su poco búfer para adaptarse a la nueva dimensión número. Además de las operaciones aritméticas pueden llevarse a cabo por medio de este objeto (que no tiene que implementar binario sumadores, multiplicadores, 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();
        }
    }

    OriginalEl autor Fernando Miguélez

  3. 3

    Esta es una tarea problema. Hay un lugar fresco bucle que se puede escribir que se compute la menor potencia de 2 >= su número de destino n.

    Ya que es una potencia de 2, el logaritmo en base 2 es el número de bits. Pero el Java math biblioteca ofrece sólo el logaritmo natural.

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

    es el número de bits.

    OriginalEl autor S.Lott

  4. 1

    Aún más sencillo:

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

    La idea aquí es analizar la cadena de nuevo como un número decimal temporalmente (uno que sólo lo que pasa a constar de todos los 1’s y 0’s) y, a continuación, utilizar la Cadena.format().

    Nota que básicamente tienes que utilizar BigInteger, porque las cadenas binarias rápidamente desbordamiento de Entero y de Larga resulta en NumberFormatExceptions si intenta utilizar Integer.fromString() o Long.fromString().

    OriginalEl autor jkschneider

  5. 1

    Intente 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

    Trate de mostrar la salida para ayudar a los usuarios a visualizar

    OriginalEl autor Anshuman Anjani Kumar

  6. 0

    Aquí una solución simple para int valores; debe ser obvio cómo extender, por ejemplo, bytes, 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 ejemplo:

      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 el parámetro de longitud adecuada para representar el valor completo.

    OriginalEl autor joel.neely

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

    De salida:

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

    OriginalEl autor Alex Reynolds

  8. 0

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

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

    De salida:00001111

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

    de salida:1111

    OriginalEl autor agarr3290417

Dejar respuesta

Please enter your comment!
Please enter your name here