Что делает значение & 0xff в Java?

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

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

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

Источник

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. & применяется для получения желаемого значения для result,

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

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

Источник

С 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 
 }

Установить (1) определенный бит

 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;
Источник

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

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

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

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

Великое объяснение Смотрите здесь

Источник

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

Источник
Другие вопросы по тегам