[bit de masque] Conversion d'un byte signé

Bonjour, souhaitant convertir mes bytes signés en bytes non signés, j'ai découvert qu'on pouvait faire cela simplement:

int unsignedbyte = signedbyte & 0xFF

Ca fonctionne à merveille, mais le seul soucis, c'est que je ne comprend pas pourquoi cela fonctionne.

Si je prend une feuille et un stylo et je fais le calcul, ça ne fonctionne pas car pour moi b & 0xFF = b, pour tout b.

La seule explication que je trouve est que le système n'est pas capable de faire l'opération '&' sur des bytes signés, donc il le convertit automatiquement en byte non signé avant d'appliquer le mask '& 0xFF', qui lui ne modifie rien.

Pouvez-vous m'éclairer sur ce point ? Merci par avance.

c'est très simple. En fait java ne gère que des types primitifs signés :

byte b= 0xFF; (équivaut a -1 en décimal)

l'astuce viens du fait que tu passe en int.

donc lorsque tu fais
int a = b & 0xFF
le système travaille en fait en 32 bits, il y a donc une conversion implicite en int de b lors de l'opération :

tu as donc a = (int)0xFF & 0xFF
a = 0xFFFFFFFF & 0x000000FF (rempli avec le bit de signe)
a = 0x000000FF
a = 0xFF (résultat : 255)

par contre si tu fais
int a = b

tu as a = (int)0xFF
a = 0xFFFFFFFF (rempli avec le bit de signe) (résultat : -1)

EDIT : Au passage, je ne pense pas que ton sujet soit a la bonne place dans J2ME

Ok, merci.

Il y a juste un détail qui m'échappe.

Quand on fait:

int a = b & 0xFF;

b est donc convertit en int, d'accord.
Mais quand est-il de 0xFF ? Apparemment, il n'est pas convertit en int, sinon dans ton exemple, on aurait -1 à l'arrivée.
0xFF est donc considéré comme un int par défaut et donc équivalent à 0x000000FF ?

Salut en effet 0xFF est un int par défaut, d'ou la conversion de b en int. Toute variable entière que tu rentre est un int par défaut après il faut faire du transtypage explicite si tu veux forcer le type (pour les long tu peux utiliser le suffixe L). Tout comme toute variable a virgule flottante sera un double par défaut (sauf si tu suffixe avec f)

En fait pour que java puisse réaliser une opération entre deux variables, il faut qu'elles aient le même type. Le transtypage implicite s'effectue toujours vers le haut (byte -> short -> int -> long), b est donc converti en int pour que l'opération entre b et 0xFF soit possible.

Maintenant si tu force le typage en byte de 0xFF :
int a = b & (byte)0xFF
Si on fait apparaitre le transtypage implicite, ca donne :

int a = (int)(b & (byte)0xFF)
-> b et 0xFF sont tout deux sur 1 octet, l'opération s'effectue donc sur 1 octet. Conversion du résultat en byte en int qui rajoute le bit de poid fort sur 3 octets

On a donc :
int a = 0xFFFFFFFF (-1)

Après tu as la rêgle concernant le transtypage entre entier et flottant :
Donc pour reprendre la priorité des type, tu as :
byte -> short -> int -> long -> float -> double
donc un entier peut être implicitement transtypé en flottant mais un flottant ne peut être implicitement transtypé en entier.

Voila, les petite rêgles de transtypage qu'il faut bien connaitre sous peine de voir apparaitre des bug dans son appli difficile a localiser (approximation, dépassement de capacité du type entrainant des résultat faussés (et donc souvent repercution a un tout autre endroit du code ...)

Merci beaucoup pour cette explication détaillée. ;)
Tout est clair à présent.