Comment convertir Int en octet non signé et en retour

Question

J'ai besoin de convertir un nombre en un octet non signé. Le nombre est toujours inférieur ou égal à 255, et afin qu'il tienne dans un seul octet.

J'ai aussi besoin de convertir des octets de retour dans ce numéro. Comment pourrais-je le faire en Java? J'ai essayé de plusieurs façons, et aucun travail. Voici ce que j'essaie de faire maintenant:

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

et maintenant, pour convertir cet octet de retour dans le nombre:

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

Clairement, cela ne fonctionne pas. Pour une raison quelconque, il est toujours convertit le nombre en 65. Toutes les suggestions?

Answer 1

Un octet est toujours signé en Java. Vous pouvez obtenir sa valeur non signée en exécutant binaire avec 0xFF, cependant:

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

Answer 2

Si vous avez besoin de convertir attendue de la valeur de 8 bits à partir d'un signé int à une valeur non signée, vous pouvez utiliser simple décalage de bits:

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 vous utilisez autre chose que de l' int que le type de base, vous aurez évidemment besoin d'ajuster le décalage: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

Aussi, gardez à l'esprit que vous ne pouvez pas utiliser byte type, cela provoquera une valeur signée comme mentionné par d'autres answerers. Le plus petit type primitif que vous pourriez utiliser pour représenter un 8 bits non signé valeur serait un short.

Answer 3

La solution fonctionne bien (merci!), Mais si vous souhaitez éviter le casting et laisser le travail de bas niveau au JDK, vous pouvez utiliser un DataOutputStream pour écrire vos entiers et un DataInputStream pour les relire. Ils sont automatiquement traités comme non signés. octets alors:

Pour convertir les int en octets binaires;

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

Les relisant dans:

 // 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. utile pour gérer les formats de données binaires (par exemple, les formats de message à plat, etc.)

Answer 4

L' Integer.toString(size) appel convertit dans le char de la représentation de votre entier, c'est à dire le char '5'. La représentation ASCII de ce caractère est la valeur de 65 ans.

Vous devez analyser la chaîne de retour à une valeur entière la première, en utilisant par exemple Integer.parseInt, pour revenir à l'original int valeur.

Comme une ligne de fond, pour un signed/unsigned de conversion, il est préférable de le laisser en String de l'image et utiliser de manipulation de bits comme @JB suggère.

Answer 5

Si vous souhaitez utiliser les classes de wrapper primitives, cela fonctionnera, mais tous les types java sont signés par défaut.

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