Por ejemplo, los bits en un byte B son 10000010, ¿cómo puedo asignar los bits a la cadena de str literalmente, es decir, str = "10000010".

Editar

Puedo leer el byte de un archivo binario, y se almacena en la matriz de bytes B. Yo uso System.out.println(Integer.toBinaryString(B[i])). el problema es

(a) cuando los bits que comienzan con (más a la izquierda) 1, la salida no es correcta, ya que convierte B[i] negativo valor int.

(b) si los bits que comienzan con 0, la salida de ignorar 0 asumir, por ejemplo, B[0] ha 00000001, la salida es 1 en lugar de 00000001

  • Estoy confundido; este es un truco?
  • Estás preguntando cómo convertir un byte a una cadena en la base 2?
  • Acabo de añadir una respuesta a otro hilo para hacer esto (la conversión de un valor a una Cadena de dígitos binarios), que trabaja para Boolean, Byte, Short, Char, Int, y Long. stackoverflow.com/a/54950845/501113
InformationsquelleAutor Sean | 2012-09-06

11 Comentarios

  1. 153

    Uso Integer#toBinaryString():

    byte b1 = (byte) 129;
    String s1 = String.format("%8s", Integer.toBinaryString(b1 & 0xFF)).replace(' ', '0');
    System.out.println(s1); //10000001
    
    byte b2 = (byte) 2;
    String s2 = String.format("%8s", Integer.toBinaryString(b2 & 0xFF)).replace(' ', '0');
    System.out.println(s2); //00000010

    DEMO.

    • He probado este método. En mi caso, puedo leer el byte de un archivo binario, y se almacena en la matriz de bytes B. Yo uso System.out.println(Integer.toBinaryString(B[i])). Cuando se utiliza este método, el problema es (a) cuando los bits comienza con (más a la izquierda) 1, la salida no es correcta, ya que convierte B[i] negativo valor int. (b) si los bits comienza con 0, la salida ignorar 0 asumir, por ejemplo, B[0] ha 00000001, la salida es 1 en lugar de 00000001
    • a) ocurre debido a un byte en Java es un signo de 8 bits complemento a dos con signo. Su valor mínimo es de -128 (2^8), y su valor máximo es 127; b) Que fácilmente se puede arreglar que el uso de este String.format("%8s", Integer.toBinaryString(b)).replace(' ', '0') a la izquierda de la almohadilla de la cadena resultante con ceros.
    • Juan: gracias por tu consejo. ¿Tiene usted alguna idea acerca de cómo la dirección (a), cómo almacenar el bit original (formato comienza con 1) en la cadena?
    • Sí, sólo & con 0xFF.
    • 0xFF, básicamente, convierte un signed byte a un unsigned integer. Por ejemplo, -129, como usted dijo, es representado por 11111111111111111111111110000001. En este caso, que, básicamente, quiere que la primera (menos significativo) de 8 bits, por lo que Y (&) con 0xFF (00000000000000000000000011111111), de manera efectiva la limpieza de la 1 a la izquierda que no nos importa, dejando fuera sólo 10000001.
    • funciona! lo siento…me acabo de perder un soporte….
    • Ah, sí, usted necesita para replace el resultado, después el String.format, como en el ejemplo anterior. Básicamente, String.format pads a la izquierda de la cadena con espacios de hasta 8 %8s y, a continuación, replace se ocupa de la sustitución de los espacios con 0s.
    • Creo que este ejemplo podría ser mejorado, porque byte b1 = (byte) 129; desbordamientos.
    • eres un dios, gracias

  2. 27

    He utilizado este. Idea Similar a la de otras respuestas, pero no veía el enfoque exacto en cualquier lugar 🙂

    System.out.println(Integer.toBinaryString((b & 0xFF) + 0x100).substring(1));

    0xFF es de 255, o 11111111 (valor máximo para un byte sin signo).
    0x100 es de 256, o 100000000

    La & upcasts el byte en entero. En ese punto, puede ser cualquier cosa, desde 0255 (00000000 a 11111111, me excluido el líder de 24 bits). + 0x100 y .substring(1) garantizar habrá ceros a la izquierda.

    Yo conté en comparación con João Silva respuesta, y esto es más de 10 veces más rápido. http://ideone.com/22DDK1 Yo no incluyen Pshemo la respuesta, ya que no almohadilla correctamente.

    • hey! tengo una pregunta acerca de esto. Tengo un Base64 representación de cadena de un PDF, que necesito para convertir a Binario. Básicamente, Base64->byte->binario.Será este el código de trabajo?
    • ¿Qué hace exactamente el + 0x100 hacer? Vas a añadir 256 para el entero resultante, pero ¿por qué?
    • Asegura que la cadena binaria es 0 collar. Por ejemplo, si b es 1, sin + 0x100 usted acaba de conseguir "1" como su cadena. Mediante la adición de 1, consigue 100000001, y si usted toma la subcadena ignorando el primer carácter que se va a obtener el adecuado "00000001". Si usted no desea que su cadena collar que usted puede simplemente utilizar Integer.toBinaryString(b & 0xff). El & 0xff corrige el negativo/complemento a dos cuestiones
  3. 7

    ¿Es esto lo que buscas?

    la conversión de Cadena de caracteres a bytes

    byte b = (byte)(int)Integer.valueOf("10000010", 2);
    System.out.println(b);//output -> -126

    la conversión de bytes de la Cadena de

    System.out.println(Integer.toBinaryString((b+256)%256));//output -> "10000010"

    O como João Silva dijo en su comentario para agregar líder 0 podemos cadena de formato para una longitud de 8 y reemplazar resultante espacios con cero, de modo que en el caso de la cadena como " 1010" vamos a conseguir "00001010"

    System.out.println(String.format("%8s", Integer.toBinaryString((b + 256) % 256))
                             .replace(' ', '0'));
  4. 3

    Se puede comprobar cada bit en el byte a continuación, agregar ya sea 0 o 1 en una cadena. Aquí hay un poco de método auxiliar que escribí para la prueba:

    public static String byteToString(byte b) {
        byte[] masks = { -128, 64, 32, 16, 8, 4, 2, 1 };
        StringBuilder builder = new StringBuilder();
        for (byte m : masks) {
            if ((b & m) == m) {
                builder.append('1');
            } else {
                builder.append('0');
            }
        }
        return builder.toString();
    }
  5. 2

    Este código, se demostrará cómo una java de tipo int se puede dividir en 4 bytes consecutivos.
    A continuación, podemos inspeccionar cada byte uso de métodos Java en comparación con bajo nivel de byte /bit interrogatorio.

    Esta es la salida que se espera cuando se ejecuta el siguiente código:

    [Input] Integer value: 8549658
    
    Integer.toBinaryString: 100000100111010100011010
    Integer.toHexString: 82751a
    Integer.bitCount: 10
    
    Byte 4th Hex Str: 0
    Byte 3rd Hex Str: 820000
    Byte 2nd Hex Str: 7500
    Byte 1st Hex Str: 1a
    
    (1st + 2nd + 3rd + 4th (int(s)) as Integer.toHexString: 82751a
    (1st + 2nd + 3rd + 4th (int(s)) ==  Integer.toHexString): true
    
    Individual bits for each byte in a 4 byte int:
    00000000 10000010 01110101 00011010

    Aquí está el código para que se ejecute:

    public class BitsSetCount
    {
    public static void main(String[] args) 
    {
    int send = 8549658;
    System.out.println( "[Input] Integer value: " + send + "\n" );
    BitsSetCount.countBits(  send );
    }
    private static void countBits(int i) 
    {
    System.out.println( "Integer.toBinaryString: " + Integer.toBinaryString(i) );
    System.out.println( "Integer.toHexString: " + Integer.toHexString(i) );
    System.out.println( "Integer.bitCount: "+ Integer.bitCount(i) );
    int d = i & 0xff000000;
    int c = i & 0xff0000;
    int b = i & 0xff00;
    int a = i & 0xff;
    System.out.println( "\nByte 4th Hex Str: " + Integer.toHexString(d) );
    System.out.println( "Byte 3rd Hex Str: " + Integer.toHexString(c) );
    System.out.println( "Byte 2nd Hex Str: " + Integer.toHexString(b) );
    System.out.println( "Byte 1st Hex Str: " + Integer.toHexString(a) );
    int all = a+b+c+d;
    System.out.println( "\n(1st + 2nd + 3rd + 4th (int(s)) as Integer.toHexString: " + Integer.toHexString(all) );
    System.out.println("(1st + 2nd + 3rd + 4th (int(s)) ==  Integer.toHexString): " + 
    Integer.toHexString(all).equals(Integer.toHexString(i) ) );
    System.out.println( "\nIndividual bits for each byte in a 4 byte int:");
    /*
    * Because we are sending the MSF bytes to a method
    * which will work on a single byte and print some
    * bits we are generalising the MSF bytes
    * by making them all the same in terms of their position
    * purely for the purpose of printing or analysis
    */
    System.out.print( 
    getBits( (byte) (d >> 24) ) + " " + 
    getBits( (byte) (c >> 16) ) + " " + 
    getBits( (byte) (b >> 8) ) + " " + 
    getBits( (byte) (a >> 0) ) 
    );
    }
    private static String getBits( byte inByte )
    {
    //Go through each bit with a mask
    StringBuilder builder = new StringBuilder();
    for ( int j = 0; j < 8; j++ )
    {
    //Shift each bit by 1 starting at zero shift
    byte tmp =  (byte) ( inByte >> j );
    //Check byte with mask 00000001 for LSB
    int expect1 = tmp & 0x01; 
    builder.append(expect1);
    }
    return ( builder.reverse().toString() );
    }
    }
  6. 2

    Obtener cada uno de los bits del byte y convertir a string.
    Decir byte tiene 8 bits, y podemos conseguir uno por uno a través de poco movimiento. Por ejemplo, podemos mover el segundo bit del byte 6 bits a la derecha, el segundo bit de bits de 8 bits, entonces y(&) con 0x0001 para limpiar la parte frontal bits.

    public static String getByteBinaryString(byte b) {
    StringBuilder sb = new StringBuilder();
    for (int i = 7; i >= 0; --i) {
    sb.append(b >>> i & 1);
    }
    return sb.toString();
    }
    • Podría usted por favor editar su respuesta a dar una explicación de por qué este código responde a la pregunta? Código sólo respuestas son desanimado, porque no enseñan la solución.
  7. 2

    Lo siento, sé que es un poco tarde… Pero tengo una manera mucho más fácil…
    A cadena binaria :

    //Add 128 to get a value from 0 - 255
    String bs = Integer.toBinaryString(data[i]+128);
    bs = getCorrectBits(bs, 8);

    getCorrectBits método :

    private static String getCorrectBits(String bitStr, int max){
    //Create a temp str to add all the zeros
    String tmpStr = "";
    for(int i = 0; i < (max - bitStr.length()); i ++){
    tmpStr += "0";
    }
    return tmpStr + bitStr;
    }
  8. 1
    String byteToBinaryString(byte b){
    StringBuilder binaryStringBuilder = new StringBuilder();
    for(int i = 0; i < 8; i++)
    binaryStringBuilder.append(((0x80 >>> i) & b) == 0? '0':'1');
    return binaryStringBuilder.toString();
    }
  9. 0

    Todos sabemos que Java no proporciona nada como el unsigned palabra clave. Por otra parte, un byte primitivo de acuerdo con el Java de especificaciones representa un valor entre −128 y 127. Por ejemplo, si un byte es cast a un int Java interpretar la primera bit como el sign y el uso de firmar la extensión.

    Entonces, cómo convertir un byte mayor que 127 a su cadena binaria de representación ??

    Nada le impide ver un byte simplemente como 8-bits y de interpretar los bits como un valor entre 0 y 255. También, usted necesita para mantener en mente que no hay nada que usted puede hacer a la fuerza de su interpretación a otra persona del método. Si un método acepta un byte, entonces el método acepta un valor entre −128 y 127 a menos que se indique explícitamente lo contrario.

    Así que la mejor manera de solucionar este problema es convertir la byte valor a un int valor llamando a la Byte.toUnsignedInt() método o de fundición como un int primitivo (int) signedByte & 0xFF. Aquí tienes un ejemplo:

    public class BinaryOperations
    {
    public static void main(String[] args)
    {
    byte forbiddenZeroBit = (byte) 0x80;
    buffer[0] = (byte) (forbiddenZeroBit & 0xFF);
    buffer[1] = (byte) ((forbiddenZeroBit | (49 << 1)) & 0xFF);
    buffer[2] = (byte) 96;
    buffer[3] = (byte) 234;
    System.out.println("8-bit header:");
    printBynary(buffer);
    }
    public static void printBuffer(byte[] buffer)
    {
    for (byte num : buffer) {
    printBynary(num);
    }
    }
    public static void printBynary(byte num)
    {
    int aux = Byte.toUnsignedInt(num);
    //int aux = (int) num & 0xFF; 
    String binary = String.format("%8s', Integer.toBinaryString(aux)).replace(' ', '0');
    System.out.println(binary);
    }
    }

    De salida

    8-bit header:
    10000000
    11100010
    01100000
    11101010
  10. -1

    Sólo una suposición, pero si usted tiene un Byte, a continuación, no podía simplemente invocar el método toString() en el objeto de obtener el valor? O, mirando a la api, utilizando byteValue()?

Dejar respuesta

Please enter your comment!
Please enter your name here