entero - int long java

Cómo convertir Int a Byte sin signo y viceversa

Question

Necesito convertir un número en un byte sin signo. El número siempre es menor o igual a 255, por lo que cabe en un byte.

También necesito convertir ese byte a ese número. ¿Cómo haría eso en Java? Lo intenté de varias maneras y no funcionó. Esto es lo que estoy tratando de hacer ahora:

int size = 5;
// Convert size int to binary
String sizeStr = Integer.toString(size);
byte binaryByte = Byte.valueOf(sizeStr);

y ahora para convertir ese byte nuevamente en el número:

Byte test = new Byte(binaryByte);
int msgSize = test.intValue();

Claramente, esto no funciona. Por alguna razón, siempre convierte el número en 65 . ¿Alguna sugerencia?

Answer 1

Java 8 proporciona Byte.toUnsignedInt para convertir byte a int mediante conversión sin firmar. En Oracle JDK esto simplemente se implementa como return ((int) x) & 0xff; porque HotSpot ya entiende cómo optimizar este patrón, pero podría estar intrínseco en otras máquinas virtuales. Lo que es más importante, no se necesita ningún conocimiento previo para comprender a qué hace una llamada a toUnsignedInt(foo) .

En total, Java 8 proporciona métodos para convertir byte y short a unsigned int y long , e int a unsigned long . Se omitió deliberadamente un método para convertir el byte en short sin signo porque la JVM solo proporciona aritmética en int y long todos modos.

Para convertir un int de nuevo a un byte, simplemente use un molde: (byte)someInt . La conversión primitiva de estrechamiento resultante descartará todos menos los últimos 8 bits.

Answer 2

La llamada Integer.toString(size) convierte en la representación char de su entero, es decir, el carácter ''5'' . La representación ASCII de ese carácter es el valor 65.

Primero debe analizar la cadena de nuevo a un valor entero, por ejemplo, utilizando Integer.parseInt , para recuperar el valor int original.

Como conclusión, para una conversión firmada / no firmada, es mejor dejar a String fuera de la imagen y usar la manipulación de bits como lo sugiere @JB.

Answer 3

La solución funciona bien (¡gracias!), Pero si quieres evitar el lanzamiento y dejar el trabajo de nivel bajo al JDK, puedes usar un DataOutputStream para escribir tus int y un DataInputStream para volver a leerlos. Se tratan automáticamente como sin firmar. bytes luego:

Para convertir int a bytes binarios;

ByteArrayOutputStream bos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(bos);
int val = 250;
dos.write(byteVal);
...
dos.flush();

Leyéndolos de nuevo en:

// important to use a (non-Unicode!) encoding like US_ASCII or ISO-8859-1,
// i.e., one that uses one byte per character
ByteArrayInputStream bis = new ByteArrayInputStream(
   bos.toString("ISO-8859-1").getBytes("ISO-8859-1"));
DataInputStream dis = new DataInputStream(bis);
int byteVal = dis.readUnsignedByte();

Esp. útil para manejar formatos de datos binarios (por ejemplo, formatos de mensajes planos, etc.)

Answer 4

Manejo de bytes y enteros sin signo con BigInteger:

byte[] b = ...                    // your integer in big-endian
BigInteger ui = new BigInteger(b) // let BigInteger do the work
int i = ui.intValue()             // unsigned value assigned to i

Answer 5

Si desea utilizar las clases de envoltura primitiva, esto funcionará, pero todos los tipos de Java están firmados por defecto.

public static void main(String[] args) {
    Integer i=5;
    Byte b = Byte.valueOf(i+""); //converts i to String and calls Byte.valueOf()
    System.out.println(b);
    System.out.println(Integer.valueOf(b));
}

Answer 6

Si solo necesita convertir un valor esperado de 8 bits de un int firmado a un valor sin signo, puede usar un simple cambio de bit:

int signed = -119;  // 11111111 11111111 11111111 10001001

/**
 * Use unsigned right shift operator to drop unset bits in positions 8-31
 */
int psuedoUnsigned = (signed << 24) >>> 24;  // 00000000 00000000 00000000 10001001 -> 137 base 10

/** 
 * Convert back to signed by using the sign-extension properties of the right shift operator
 */
int backToSigned = (psuedoUnsigned << 24) >> 24; // back to original bit pattern

http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op3.html

Si utiliza algo que no sea int como tipo de base, obviamente tendrá que ajustar la cantidad de desplazamiento: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

Además, tenga en cuenta que no puede usar el tipo de byte , al hacerlo tendrá como resultado un valor firmado como lo mencionan otros respondedores. El tipo primitivo más pequeño que podría usar para representar un valor sin signo de 8 bits sería un short .

Answer 7

Un byte siempre se firma en Java. Sin embargo, puede obtener su valor sin signo binario-anding con 0xFF:

int i = 234;
byte b = (byte) i;
System.out.println(b); // -22
int i2 = b & 0xFF;
System.out.println(i2); // 234

Answer 8

en java 7

public class Main {
    public static void main(String[] args) {
        byte b =  -2;
        int i = 0 ;
        i = ( b & 0b1111_1111 ) ;
        System.err.println(i);
    }
}

resultado: 254