web-dev-qa-db-fra.com

Que fait la valeur & 0xff en Java?

J'ai le code Java suivant:

byte value = 0xfe; // corresponds to -2 (signed) and 254 (unsigned)
int result = value & 0xff;

Le résultat est 254 à l'impression, mais je n'ai aucune idée du fonctionnement de ce code. Si l'opérateur & est simplement binaire, alors pourquoi ne résulte-t-il pas en un octet et en un entier?

javaintegerbytebitwise-and
78
dagronlund

Il définit result sur la valeur (non signée) résultant de l'insertion des 8 bits de value dans les 8 bits les plus bas de result.

La raison pour laquelle quelque chose comme ceci est nécessaire est que byte est un type signé en Java. Si vous venez d'écrire:

int result = value;

alors result se retrouverait avec la valeur ff ff ff fe au lieu de 00 00 00 fe. Une autre subtilité est que le & est défini pour ne fonctionner que sur les valeurs int1Alors, que se passe-t-il?

  1. value est promu en int (ff ff ff fe).
  2. 0xff est un int littéral (00 00 00 ff).
  3. Le & est appliqué pour générer la valeur souhaitée pour result.

(Le fait est que la conversion en int se produit avant le l'opérateur & est appliqué.)

1Pas tout à fait. L'opérateur & fonctionne également sur les valeurs long, si l'un des opérandes est un long. Mais pas sur byte. Voir la spécification du langage Java, sections 15.22.1 et 5.6.2 .

145
Ted Hopp

De http://www.coderanch.com/t/236675/Java-programmer-SCJP/certification/xff

Le littéral hexadécimal 0xFF est un égal égal (255). Java représente int en 32 bits. Cela ressemble à ceci en binaire:

00000000 00000000 00000000 11111111

Quand vous faites un peu sage ET avec cette valeur (255) sur n’importe quel nombre, il va masquer (créer des ZÉROs) tous sauf les 8 bits les plus bas du nombre (sera tel quel).

... 01100100 00000101 & ...00000000 11111111 = 00000000 00000101

& est quelque chose comme% mais pas vraiment .

Et pourquoi 0xff? ceci dans ((puissance de 2) - 1) . Tous ((puissance de 2) - 1) (par exemple 7, 255 ...) se comporteront comme% opérateur.

Ensuite
En binaire, 0 correspond à tous les zéros et 255 se présente comme suit:

00000000 00000000 00000000 11111111

Et -1 ressemble à ceci

11111111 11111111 11111111 11111111

Lorsque vous faites un bit AND de 0xFF et une valeur comprise entre 0 et 255, le résultat est identique à la valeur. Et si une valeur supérieure à 255 reste, le résultat sera compris entre 0 et 255.

Cependant, si vous le faites:

-1 & 0xFF

vous recevez

00000000 00000000 00000000 11111111, qui n'égale PAS la valeur d'origine de -1 (11111111 est égal à 255 en décimal).


Peu plus de manipulation de bits: (Pas lié à la question)

X >> 1 = X/2
X << 1 = 2X

Vérifier qu'un bit particulier est activé (1) ou non (0), puis

 int thirdBitTobeChecked =   1 << 2   (...0000100)
 int onWhichThisHasTobeTested = 5     (.......101)

 int isBitSet = onWhichThisHasTobeTested  & thirdBitTobeChecked;
 if(isBitSet > 0) {
  //Third Bit is set to 1 
 }

Définir (1) un bit particulier

 int thirdBitTobeSet =   1 << 2    (...0000100)
 int onWhichThisHasTobeSet = 2     (.......010)
 onWhichThisHasTobeSet |= thirdBitTobeSet;

ReSet (0) un bit particulier

int thirdBitTobeReSet =   ~(1 << 2)  ; //(...1111011)
int onWhichThisHasTobeReSet = 6      ;//(.....000110)
onWhichThisHasTobeReSet &= thirdBitTobeReSet;

XOR 

Notez simplement que si vous effectuez l'opération XOR deux fois, la même valeur sera obtenue.

byte toBeEncrypted = 0010 0110
byte salt          = 0100 1011

byte encryptedVal  =  toBeEncrypted ^ salt == 0110 1101
byte decryptedVal  =  encryptedVal  ^ salt == 0010 0110 == toBeEncrypted :)

Une autre logique avec XOR est

if     A (XOR) B == C (salt)
then   C (XOR) B == A
       C (XOR) A == B

Ce qui précède est utile pour échanger deux variables sans temp comme ci-dessous

a = a ^ b; b = a ^ b; a = a ^ b;

OR

a ^= b ^= a ^= b;
42
Kanagavelu Sugumar

Cela aide à réduire beaucoup de codes. Il est parfois utilisé dans des valeurs RVB composées de 8 bits. 

où 0xff signifie 24 (0) et 8 (1) comme 00000000 00000000 00000000 11111111 

Il masque effectivement la variable, de sorte qu'il ne laisse que la valeur dans les 8 derniers bits et ignore tout le reste des bits.

C’est ce qui se produit le plus souvent dans les cas de tentative de transformation des valeurs de couleur d’un format spécial en valeurs RVB standard (d’une longueur de 8 bits).

Grande explication Voir ici

4
Xar E Ahmer

Dans un système au format 32 bits, la valeur hexadécimale 0xff représente 00000000000000000000000011111111 et 255(15*16^1+15*16^0) en décimal. et l'opérateur au niveau des bits & masque les 8 bits les plus à droite comme dans le premier opérande. 

0
manish kumar