java - recursivo - Cómo convertir un byte a su representación de cadena binaria

convertir una cadena a codigo ascii en java

Question

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

Editar

Leí el byte de un archivo binario y lo almacené en la matriz de bytes B Yo uso System.out.println(Integer.toBinaryString(B[i])) . el problema es

(a) cuando los bits comienzan con (la izquierda) 1, la salida no es correcta porque convierte B[i] a un valor int negativo.

(b) si los bits comienzan con 0 , la salida ignora 0 , por ejemplo, suponiendo que B[0] tiene 00000001, la salida es 1 lugar de 00000001

Answer 1

¿Es esto lo que estás buscando?

//converting from String to byte
Byte b= (byte)(int)Integer.valueOf("10000010", 2);
System.out.println(b);// output -> -126
//converting from byte to String
System.out.println(Integer.toBinaryString((b+256)%256));// output -> "10000010"

O como dijo João Silva en su comentario

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

Answer 2

Este código demostrará cómo una int java se puede dividir en sus 4 bytes consecutivos. Luego podemos inspeccionar cada byte usando métodos Java en comparación con la interrogación de byte / bit de bajo nivel.

Este es el resultado esperado cuando 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 ejecutar:

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

Answer 3

Lo siento, sé que esto es un poco tarde ... Pero tengo una manera mucho más fácil ... A la secuencia binaria:

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

Método getCorrectBits:

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

Answer 4

Obtenga cada bit de byte y conviértalo en string. Say byte tiene 8 bits, y podemos obtenerlos uno por uno mediante un movimiento de bit. Por ejemplo, movemos el segundo bit del byte 6 bits hacia la derecha, el segundo bit al final del bit de 8 bits, luego y (&) con 0x0001 para limpiar los bits frontales.

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

Answer 5

Puede verificar cada bit en el byte y luego agregar 0 o 1 a una cadena. Aquí hay un pequeño método de ayuda que escribí para probar:

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

Answer 6

Simplemente adivinando aquí, pero si tienes un byte, ¿no podrías simplemente invocar toString () en el objeto para obtener el valor? O, echando un vistazo a la api , utilizando byteValue ()?

Answer 7

Usé esto. Idea similar a otras respuestas, pero no vio el enfoque exacto en cualquier lugar :)

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

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

El & sube el byte a un entero. En ese punto, puede ser cualquier cosa desde 0 hasta 255 ( 00000000 a 11111111 , 11111111 los 24 bits iniciales). + 0x100 y .substring(1) aseguran que habrá ceros a la izquierda.

Lo sincronicé en comparación con la respuesta de João Silva , y esto es más de 10 veces más rápido. http://ideone.com/22DDK1 No incluí la respuesta de Pshemo ya que no se ajusta correctamente.

Answer 8

Use 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 .

Answer 9

Integer.toBinaryString((byteValue & 0xFF) + 256).substring(1)

Answer 10

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