¿Qué hace value & 0xff en Java?

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

El literal hexadecimal 0xFF es un int(255) igual. Java representa int como 32 bits. Se ve así en binario:

00000000 00000000 00000000 11111111

Cuando haces un poco sabio Y con este valor(255) en cualquier número, va a enmascarar(hacer CEROs) todos menos los 8 bits más bajos del número (será como es).

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

& es algo así como % pero no realmente.

¿Y por qué 0xff? esto en ((potencia de 2) - 1). Todos ((potencia de 2) - 1) (p. ej. 7, 255...) se comportará algo así como % operador.

Entonces
En binario, 0 es, todos los ceros, y 255 se ve así:

00000000 00000000 00000000 11111111

Y -1 se parece a esto

11111111 11111111 11111111 11111111

Cuando haces un Y de 0xFF y cualquier valor de 0 a 255, el resultado es exactamente el mismo que el valor. Y si cualquier valor superior a 255 todavía el resultado estará dentro de 0-255.

Sin embargo, si lo haces:

-1 & 0xFF

Usted get

00000000 00000000 00000000 11111111, que NO es igual al valor original de -1 (11111111 es 255 en decimal).

Pocas manipulaciones de bits más: (No relacionadas con la pregunta)

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

Compruebe que cualquier bit en particular se establece (1) o no (0) entonces

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

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

Establece (1) un bit en particular

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

Restablecer (0) un bit en particular

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

XOR

Solo tenga en cuenta que si realiza XOR operación dos veces, dará como resultado el mismo valor.

byte toBeEncrypted = 0010 0110
byte salt          = 0100 1011

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

Una lógica más con XOR es

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

Lo anterior es útil para intercambiar dos variables sin temp como abajo

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

O

a ^= b ^= a ^= b;

Ayuda a reducir muchos códigos. Se utiliza ocasionalmente en valores RGB que consisten en 8 bits.

Donde 0xff significa 24 (0's) y 8(1's) como 00000000 00000000 00000000 11111111

Efectivamente enmascara la variable para que deje solo el valor en los últimos 8 bits, e ignore todo el resto de los bits

Se ve más en casos como cuando se trata de transformar los valores de color de un formato especial a valores RGB estándar (que es de 8 bits de largo).

Genial Explicación Ver aquí

En el sistema de formato de 32 bits, el valor hexadecimal 0xff representa 00000000000000000000000011111111 que es 255(15*16^1+15*16^0) en decimal. y el operador bitwise & enmascara los mismos 8 bits a la derecha que en el primer operando.