Что делает value & 0xff в Java?

У меня есть следующий код Java:

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

результат 254 при печати, но я понятия не имею, как этот код работает. Если & оператор просто побитовый, тогда почему он не приводит к байту и вместо целого числа?

4 69
javascript bytecode integer bitwise-and

4 ответа:

задает result к значению (без знака), полученному в результате размещения 8 бит value в младшие 8 бит result.

что-то вроде этого нужно, - это byte является подписанным типом в Java. Если вы только что написали:

int result = value;

затем result будет в конечном итоге со значением ff ff ff fe вместо 00 00 00 fe. Еще одна тонкость заключается в том, что & определяется для работы только на int значения1, так что происходит это:

  1. value становится int (ff ff ff fe).
  2. 0xff это int литерал (00 00 00 ff).
  3. The & применяется для получения желаемого значения для result.

(дело в том, что преобразование int происходит до the оператор.)

1Ну, не совсем. Элемент & оператор работает на long значения, если любой из операндов является long. Но не на byte. См. спецификацию языка Java, разделы 15.22.1 и 5.6.2.

131

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

шестнадцатеричный литерал 0xFF равен int (255). Java представляет int как 32 бита. Это выглядит так в двоичном формате:

00000000 00000000 00000000 11111111

когда вы делаете немного мудрым и с этим значением(255) на любом числе, он будет маскировать(делать нули) все, кроме самых низких 8 бит числа (будет как есть).

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

& что-то вроде %, но не действительно.

и почему значение 0xFF? это в ((Мощность 2) - 1). Все ((мощность 2) - 1) (например 7, 255...) будет вести себя что-то вроде % оператора.

затем
В двоичном формате 0-это все нули, а 255 выглядит так:

00000000 00000000 00000000 11111111

и -1 выглядит так

11111111 11111111 11111111 11111111

когда вы делаете побитовое и 0xFF и любое значение от 0 до 255, результат точно такой же, как значение. И если любое значение выше 255 все еще результат будет в пределах 0-255.

если вы:

-1 & 0xFF

вы получаете

00000000 00000000 00000000 11111111, что не равно исходному значению -1 (11111111 255 в десятичной системе счисления).


еще несколько битовых манипуляций: (не связанных с вопросом)

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

проверьте, установлен ли какой-либо конкретный бит(1) или нет (0), то

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

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

Set (1) a particular бит

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

сброс (0) определенного бита

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

XOR

просто обратите внимание, что если вы выполняете операцию XOR дважды, то получите одно и то же значение.

byte toBeEncrypted = 0010 0110
byte salt          = 0100 1011

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

еще одна логика с XOR-это

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

выше полезно поменять две переменные без temp, как показано ниже

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

или

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

это поможет уменьшить количество кодов. Он иногда используется в значениях RGB, которые состоят из 8 бит.

где 0xff означает 24(0 ) и 8(1-х) как 00000000 00000000 00000000 11111111

Он эффективно маскирует переменную, поэтому он оставляет только значение в последних 8 битах и игнорирует все остальные биты

это видно в большинстве случаев, например, при попытке преобразовать значения цвета из специального формата в стандартные значения RGB (что составляет 8 бит длинный.)

отличное объяснение смотрите здесь

3

в 32-битном формате системы шестнадцатеричное значение 0xff представляет 00000000000000000000000011111111 что это 255(15*16^1+15*16^0) в десятичной системе счисления. и побитовый оператор & маскирует те же самые 8 правых битов, что и в первом операнде.

0