Pourquoi la conversion d'un int en octet en Java donne-t-elle une valeur négative, et comment pouvons-nous récupérer la valeur originale non signée ?

Anomalies intrigantes de conversion d'int et d'octets

Lors de la conversion d'un int en octet en Java, le comportement peut sembler inattendu, en particulier si l'on considère l'apparent perte de données et le signe négatif attribué à l'octet résultant. Pour résoudre cette énigme, explorons les subtilités des types de données primitifs et de la représentation en complément à deux.

Comprendre les types primitifs et le complément à deux :

En Java, un int occupe 32 bits, alors qu'un octet n'occupe que 8 bits. De plus, les types primitifs comme int et byte suivent la représentation du complément à deux. Dans ce schéma, le bit le plus élevé (MSB) détermine le signe et des bits supplémentaires conduisent à sa réplication.

Conversion bit à bit d'int en octet :

Lors de la conversion d'un int en un octet, Java extrait uniquement les 8 bits les moins significatifs et attribue la valeur en conséquence. Cependant, le MSB d'un int, désormais le bit de signe de l'octet, joue un rôle important dans le résultat.

Révéler la vérité cachée :

Disséquons notre exemple déroutant :

int i = 132;

byte b = (byte)i; // Implicit narrowing conversion

System.out.println(b); // Prints -124

La représentation binaire 32 bits de 132 :

00000000000000000000000010000100

Extraction des 8 bits les moins significatifs (10000100) :

10000100

Conversion en représentation en complément à deux :

11111000

Java interprète cela comme un valeur négative en raison de la configuration binaire inversée, ce qui fait que -124 est imprimé.

Résoudre l'énigme :

Pour récupérer la valeur originale non signée de 8 bits de l'octet, nous pouvons effectuer une opération ET au niveau du bit :

byte signedByte = -124;
int unsignedByte = signedByte & 0xff; // 0xff = 11111111b

Cette opération masque les bits de signe superflus, donnant ce qui suit résultat :

Unsigned value: 10000100 (84 in decimal)

Résumé de la supercherie :

Lors de la conversion entier en octet, Java ignore les 24 bits les plus à gauche via un rétrécissement implicite. Le bit de signe, à l'origine le 8ème bit de l'int, devient le MSB dans l'octet, influençant son interprétation. Pour dévoiler la valeur non signée, une opération ET au niveau du bit est nécessaire, effaçant efficacement les bits de signe.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!