¿Podemos hacer un byte sin firmar en Java?

Estoy tratando de convertir un byte firmado en unsigned. El problema es que los datos que estoy recibiendo no están firmados y Java no admite el byte sin firmar, por lo que cuando lee los datos, los trata como firmados.

Intenté convertirlo con la siguiente solución que obtuve de Stack Overflow.

public static int unsignedToBytes(byte a)
{
    int b = a & 0xFF;
    return b;
}

Pero cuando nuevamente se convierte en byte, obtengo los mismos datos firmados. Estoy tratando de usar estos datos como un parámetro para una función de Java que acepta solo un byte como parámetro, por lo que no puedo usar ningún otro tipo de datos. ¿Como puedo solucionar este problema?

No estoy seguro de entender tu pregunta.

Acabo de probar esto y para el byte -12 (valor con signo) devolvió el entero 244 (equivalente al valor de byte sin signo pero escrito como int):

  public static int unsignedToBytes(byte b) {
    return b & 0xFF;
  }

  public static void main(String[] args) {
    System.out.println(unsignedToBytes((byte) -12));
  }

¿Es lo que quieres hacer?

Java no permite expresar 244 como un bytevalor, como lo haría C. Para expresar enteros positivos arriba Byte.MAX_VALUE(127) tienes que usar otro tipo de entero, como short, into long.

El hecho de que las primitivas estén firmadas en Java es irrelevante para la forma en que están representadas en la memoria / tránsito: un byte tiene solo 8 bits y depende de usted si lo interpreta como un rango con signo. No hay una bandera mágica que diga "esto está firmado" o "esto no está firmado".

A medida que se firman las primitivas, el compilador de Java le impedirá asignar un valor superior a +127 a un byte (o inferior a -128). Sin embargo, no hay nada que te impida rechazar un int (o short) para lograr esto:

int i = 200; // 0000 0000 0000 0000 0000 0000 1100 1000 (200)
byte b = (byte) 200; // 1100 1000 (-56 by Java specification, 200 by convention)

/*
 * Will print a negative int -56 because upcasting byte to int does
 * so called "sign extension" which yields those bits:
 * 1111 1111 1111 1111 1111 1111 1100 1000 (-56)
 *
 * But you could still choose to interpret this as +200.
 */
System.out.println(b); // "-56"

/*
 * Will print a positive int 200 because bitwise AND with 0xFF will
 * zero all the 24 most significant bits that:
 * a) were added during upcasting to int which took place silently
 *    just before evaluating the bitwise AND operator.
 *    So the `b & 0xFF` is equivalent with `((int) b) & 0xFF`.
 * b) were set to 1s because of "sign extension" during the upcasting
 *
 * 1111 1111 1111 1111 1111 1111 1100 1000 (the int)
 * &
 * 0000 0000 0000 0000 0000 0000 1111 1111 (the 0xFF)
 * =======================================
 * 0000 0000 0000 0000 0000 0000 1100 1000 (200)
 */
System.out.println(b & 0xFF); // "200"

/*
 * You would typically do this *within* the method that expected an 
 * unsigned byte and the advantage is you apply `0xFF` only once
 * and than you use the `unsignedByte` variable in all your bitwise
 * operations.
 *
 * You could use any integer type longer than `byte` for the `unsignedByte` variable,
 * i.e. `short`, `int`, `long` and even `char`, but during bitwise operations
 * it would get casted to `int` anyway.
 */
void printUnsignedByte(byte b) {
    int unsignedByte = b & 0xFF;
    System.out.println(unsignedByte); // "200"
}

Guía completa para trabajar con bytes sin firmar en Java:

Byte sin firmar en Java

(Fuente de esta respuesta).

El lenguaje Java no proporciona nada parecido a la unsignedpalabra clave. A de byteacuerdo con la especificación del lenguaje representa un valor entre −128 y 127. Por ejemplo, si bytese emite a intJava interpretará el primer bit como signo y usará la extensión de signo .

Dicho esto, nada le impide ver bytesimplemente 8 bits e interpretar esos bits como un valor entre 0 y 255. Solo tenga en cuenta que no hay nada que pueda hacer para forzar su interpretación sobre el método de otra persona. Si un método acepta a byte, entonces ese método acepta un valor entre -128 y 127 a menos que se indique explícitamente lo contrario.

Aquí hay un par de conversiones / manipulaciones útiles para su conveniencia:

Conversiones a / desde int

// From int to unsigned byte
int i = 200;                    // some value between 0 and 255
byte b = (byte) i;              // 8 bits representing that value

// From unsigned byte to int
byte b = 123;                   // 8 bits representing a value between 0 and 255
int i = b & 0xFF;               // an int representing the same value

(O, si tienes Java 8+, úsalo Byte.toUnsignedInt).

Análisis / formateo

La mejor manera es usar las conversiones anteriores:

// Parse an unsigned byte
byte b = (byte) Integer.parseInt("200");

// Print an unsigned byte
System.out.println("Value of my unsigned byte: " + (b & 0xFF));

Aritmética

La representación de 2 complementos "simplemente funciona" para sumar, restar y multiplicar:

// two unsigned bytes
byte b1 = (byte) 200;
byte b2 = (byte) 15;

byte sum  = (byte) (b1 + b2);  // 215
byte diff = (byte) (b1 - b2);  // 185
byte prod = (byte) (b2 * b2);  // 225

La división requiere la conversión manual de operandos:

byte ratio = (byte) ((b1 & 0xFF) / (b2 & 0xFF));

No hay bytes primitivos sin signo en Java. Lo habitual es lanzarlo a un tipo más grande:

int anUnsignedByte = (int) aSignedByte & 0xff;

Creo que las otras respuestas han cubierto la representación de la memoria y cómo las maneja depende del contexto de cómo planea usarla. Agregaré que Java 8 agregó algo de soporte para tratar con tipos sin firmar . En este caso, podrías usarByte.toUnsignedInt

int unsignedInt = Byte.toUnsignedInt(myByte);

Una nota al margen, si desea imprimirlo, simplemente puede decir

byte b = 255;
System.out.println((b < 0 ? 256 + b : b));

Si crees que estás buscando algo como esto.

public static char toUnsigned(byte b) {
    return (char) (b >= 0 ? b : 256 + b);
}

Adamski proporcionó la mejor respuesta, pero no está del todo completa, así que lea su respuesta, ya que explica los detalles que no soy.

Si tiene una función del sistema que requiere que se le pase un byte sin signo, puede pasar un byte con signo, ya que lo tratará automáticamente como un byte sin signo.

Entonces, si una función del sistema requiere cuatro bytes, por ejemplo, 192 168 0 1 como bytes sin signo, puede pasar -64 -88 0 1, y la función seguirá funcionando, porque el acto de pasarlos a la función los anulará. .

Sin embargo, es poco probable que tenga este problema ya que las funciones del sistema están ocultas detrás de las clases para la compatibilidad multiplataforma, aunque algunos de los métodos de lectura java.io devuelven bytes no seleccionados como int.

Si desea que esto funcione, intente escribir bytes firmados en un archivo y vuelva a leerlos como bytes sin firmar.

Tú también puedes:

public static int unsignedToBytes(byte a)
{
    return (int) ( ( a << 24) >>> 24);
}    

Explicación:

digamos a = (byte) 133;

En la memoria se almacena como: "1000 0101" (0x85 en hexadecimal)

Por lo que su representación se traduce sin signo = 133, firmado = -123 (como complemento a 2)

a << 24

Cuando el desplazamiento a la izquierda se realiza 24 bits a la izquierda, el resultado ahora es un entero de 4 bytes que se representa como:

"10000101 00000000 00000000 00000000" (o "0x85000000" en hexadecimal)

entonces nosotros tenemos

(a << 24) >>> 24

y se desplaza nuevamente a la derecha 24 bits pero se llena con ceros a la izquierda. Entonces resulta a:

"00000000 00000000 00000000 10000101" (o "0x00000085" en hexadecimal)

y esa es la representación sin signo que equivale a 133.

Si trató de emitir a = (int) a; , lo que sucedería es que mantiene la representación del byte del complemento de 2 y lo almacena como int también como complemento de 2:

(int) "10000101" ---> "11111111 11111111 11111111 10000101"

Y eso se traduce como: -123

Estoy tratando de usar estos datos como parámetro para una función de Java que acepta solo un byte como parámetro

Esto no es sustancialmente diferente de una función que acepta un número entero al que desea pasar un valor mayor que 2 ^ 32-1.

Parece que depende de cómo se defina y documente la función; Puedo ver tres posibilidades:

1. Puede documentar explícitamente que la función trata el byte como un valor sin signo, en cuyo caso la función probablemente debería hacer lo que espera pero parece implementarse incorrectamente. Para el caso de enteros, la función probablemente declararía el parámetro como un entero sin signo, pero eso no es posible para el caso de bytes.

2. Puede documentar que el valor de este argumento debe ser mayor que (o tal vez igual a) cero, en cuyo caso está haciendo un mal uso de la función (pasando un parámetro fuera de rango), esperando que haga más de lo que fue diseñado para hacer. Con cierto nivel de soporte de depuración, puede esperar que la función arroje una excepción o falle una aserción.

3. La documentación puede no decir nada, en cuyo caso un parámetro negativo es, bueno, un parámetro negativo y si eso tiene algún significado depende de lo que haga la función. Si esto no tiene sentido, entonces tal vez la función realmente debería definirse / documentarse como (2). Si esto es significativo de una manera no obvia (p. Ej., Los valores no negativos se usan para indexar en una matriz, y los valores negativos se usan para indexar desde el final de la matriz, entonces -1 significa el último elemento) la documentación debe decir qué significa y esperaría que no sea lo que quieres que haga de todos modos.

Si tiene una función que debe pasar un byte firmado, ¿qué espera que haga si pasa un byte sin firmar?

¿Por qué no puedes usar ningún otro tipo de datos?

Por lo general, puede usar un byte como byte sin firmar con traducciones simples o sin traducciones. Todo depende de cómo se use. Tendrás que aclarar qué tienes que hacer con él.

Aunque puede parecer molesto (proveniente de C) que Java no incluyó el byte sin signo en el lenguaje, realmente no es gran cosa ya que una simple operación "b & 0xFF" produce el valor sin signo para el byte b (firmado) en el (raro) situaciones que realmente se necesitan. Los bits en realidad no cambian, solo la interpretación (que es importante solo cuando se realizan, por ejemplo, algunas operaciones matemáticas en los valores).

No hay un byte sin signo en Java, pero si desea mostrar un byte, puede hacer,

int myInt = 144;

byte myByte = (byte) myInt;

char myChar = (char) (myByte & 0xFF);

System.out.println("myChar :" + Integer.toHexString(myChar));

Salida:

myChar : 90

Para obtener más información, consulte Cómo mostrar un valor hexadecimal / byte en Java .

Según las limitaciones en Java, el byte sin signo es casi imposible en el formato de tipo de datos actual. Puede buscar otras bibliotecas de otro idioma para lo que está implementando y luego puede llamarlas utilizando JNI .

Si y no. He estado cavando con este problema. Como si entendiera esto:

El hecho es que Java ha firmado el número entero -128 a 127 .. Es posible presentar un Java no firmado con:

public static int toUnsignedInt(byte x) {
    return ((int) x) & 0xff;
}

Si, por ejemplo, agrega -12 número firmado para que no esté firmado, obtiene 244. Pero puede usar ese número nuevamente en firmado, debe volver a firmar y volverá a ser -12.

Si intenta agregar 244 al byte de Java, saldrá de la excepción de índice de excepción.

Salud..

Si desea bytes sin firmar en Java, simplemente reste 256 del número que le interesa. Producirá el complemento de dos con un valor negativo, que es el número deseado en bytes sin signo.

Ejemplo:

int speed = 255; //Integer with the desired byte value
byte speed_unsigned = (byte)(speed-256);
//This will be represented in two's complement so its binary value will be 1111 1111
//which is the unsigned byte we desire.

Debe usar estos trucos sucios cuando use leJOS para programar el ladrillo NXT .