O que o valor & 0xff faz em Java?

Eu tenho o seguinte código Java:

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

O resultado é 254 quando impresso, mas não tenho ideia de como esse código funciona. Se o operador & é simplesmente bit a bit, então por que ele não resulta em um byte e um inteiro?

Ele define o result para o valor (não assinado) resultante da colocação dos 8 bits de value nos 8 bits mais baixos do result .

A razão pela qual algo assim é necessário é que o byte é um tipo assinado em Java. Se você acabou de escrever:

 int result = value; 

então result com o valor ff ff ff fe vez de 00 00 00 fe . Uma outra sutileza é que o & é definido para operar somente em valores int 1 , então o que acontece é:

  1. value é promovido a um int ( ff ff ff fe ).
  2. 0xff é um literal int ( 00 00 00 ff ).
  3. O & é aplicado para gerar o valor desejado para o result .

(O ponto é que a conversão para int acontece antes que o operador & seja aplicado.)

1 Bem, não é bem assim. O operador & trabalha com valores long , se um dos operandos for long . Mas não no byte . Veja a especificação da linguagem Java, seções 15.22.1 e 5.6.2 .

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

O literal hexadecimal 0xFF é um int int (255). Java representa int como 32 bits. Parece assim em binário:

 00000000 00000000 00000000 11111111 

Quando você faz um bit sábio E com este valor (255) em qualquer número, ele irá mascarar (fazer ZEROs) todos menos os 8 bits mais baixos do número (será como está).

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

e é algo como% mas não realmente .

E por que 0xff? isso em ((potência de 2) – 1). Todos ((potência de 2) – 1) (por exemplo, 7, 255 …) se comportarão como% operator.

Então
Em binário, 0 é, todos os zeros e 255 se parece com isto:

 00000000 00000000 00000000 11111111 

E -1 parece com isso

 11111111 11111111 11111111 11111111 

Quando você faz um bit a bit AND de 0xFF e qualquer valor de 0 a 255, o resultado é exatamente igual ao valor. E se qualquer valor maior que 255 ainda o resultado estará dentro de 0-255.

No entanto, se você fizer:

 -1 & 0xFF 

você consegue

00000000 00000000 00000000 11111111 , que NÃO é igual ao valor original de -1 ( 11111111 é 255 em decimal).

Mais algumas manipulações de bits: (não relacionadas à pergunta)

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

Verifique se algum bit específico está definido (1) ou não (0)

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

Definir (1) um bit específico

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

ReSet (0) um bit em particular

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

XOR

Apenas observe que, se você executar a operação XOR duas vezes, resultará no mesmo valor.

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

Mais uma lógica com XOR é

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

O acima é útil para trocar duas variables ​​sem temp como abaixo

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

OU

 a ^= b ^= a ^= b; 

Isso ajuda a reduzir muitos códigos. É ocasionalmente usado em valores RGB que consistem em 8bits.

onde 0xff significa 24 (0’s) e 8 (1’s) como 00000000 00000000 00000000 11111111

Ele efetivamente mascara a variável, deixando apenas o valor nos últimos 8 bits e ignorando todo o restante dos bits.

É mais visto em casos como ao tentar transformar valores de colors de um formato especial para valores RGB padrão (que tem 8 bits de comprimento).

Grande Explicação Veja aqui

No sistema de formato de 32 bits, o valor hexadecimal 0xff representa 00000000000000000000000011111111 que é 255(15*16^1+15*16^0) em decimal. e o operador bit a bit & mascara os mesmos 8 bits da direita como no primeiro operando.