bitwise - shift en java

¿Qué hace value & 0xff en Java?

Question

Tengo el siguiente código de Java:

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

El resultado es 254 cuando se imprime, pero no tengo idea de cómo funciona este código. Si el operador & es simplemente en modo bit, ¿por qué no da como resultado un byte y en su lugar un número entero?

Answer 1

Ayuda a reducir muchos códigos. Ocasionalmente se usa en valores RGB que constan de 8 bits.

donde 0xff significa 24 (0) y 8 (1) como 00000000 00000000 00000000 11111111

Enmascara efectivamente la variable, por lo que deja solo el valor en los últimos 8 bits e ignora 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 tienen 8 bits de longitud).

Gran explicación Ver aquí

Answer 2

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

El hexadecimal literal 0xFF es un int igual (255). 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 CERO) todo excepto los 8 bits más bajos del número (será como está).

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

& es algo así como% pero no really .

¿Y por qué 0xff? esto en ((potencia de 2) - 1). Todo ((potencia de 2) - 1) (por ejemplo, 7, 255 ...) se comportará como el operador%.

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

00000000 00000000 00000000 11111111

Y -1 se ve así

11111111 11111111 11111111 11111111

Cuando haces un Y a nivel de bits de 0xFF y cualquier valor de 0 a 255, el resultado es exactamente el mismo que el valor. Y si hay algún valor superior a 255, el resultado estará dentro de 0-255.

Sin embargo, si lo haces:

-1 & 0xFF

usted obtiene

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

Pocos más manipulación de bits: (No relacionado con la pregunta)

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

Verifique que cualquier bit en particular esté configurado (1) o no (0) luego

 int thirdBitTobeChecked = 1 << 2 (...0000100)
int onWhichThisHasTobeTested = 5 (.......101)
int isBitSet = onWhichThisHasTobeTested & thirdBitTobeChecked;
if(isBitSet > 0) {
//Third Bit is set to 1
}

Establezca (1) un bit en particular

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

Reestablecer (0) un bit en particular

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

XOR

Solo tenga en cuenta que si realiza la operación XOR dos veces, obtendrá 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 a continuación

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

O

a ^= b ^= a ^= b;

Answer 3

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 más a la derecha que en el primer operando.

Answer 4

Establece el result en el valor (sin signo) resultante de poner los 8 bits de value en los 8 bits más bajos de result .

La razón por la cual algo así es necesario es que el byte es un tipo firmado en Java. Si acabas de escribir:

int result = value;

entonces el result terminaría con el valor de ff ff ff fe lugar de 00 00 00 fe . Otra sutileza es que el & se define para operar solo en los valores int ¹ , entonces lo que sucede es:

1. value se promueve a un int ( ff ff ff fe ).
2. 0xff es un literal int ( 00 00 00 ff ).
3. El & se aplica para obtener el valor deseado para el result .

(El punto es que la conversión a int ocurre antes de que se aplique el operador & ).

1 _{Bueno, no del todo. El operador & funciona también en valores long , si cualquiera de los operandos es long . Pero no en byte . Consulte la Especificación del lenguaje Java, secciones 15.22.1 y 5.6.2 .}