Разбиране на стойността & 0xff в Java

1. Общ преглед

0xff е число, представено в шестнадесетичната цифрова система (основа 16). Състои се от две F числа в шестнадесетично число. Както знаем, F в шестнадесетично число е еквивалентно на 1111 в двоичната цифрова система. И така, 0xff в двоичен файл е 11111111.

В тази статия ще открием как да използваме стойността 0xff . Освен това ще видим как да го представим с помощта на множество типове данни и как да го използваме с оператора & . Накрая ще разгледаме някои от предимствата, свързани с използването му.

2. Представяне на 0xff с различни типове данни

Java ни позволява да дефинираме числа, интерпретирани като шестнадесетични (основа 16), като използваме префикса 0x , последван от целочислен литерал.

Стойността 0xff е еквивалентна на 255 в десетичен знак без подпис, -127 в десетичен знак и 11111111 в двоичен.

Така че, ако дефинираме променлива int със стойност 0xff , тъй като Java представлява цели числа, използвайки 32 бита , стойността на 0xff е 255 :

int x = 0xff; assertEquals(255, x);

Ако обаче дефинираме байтова променлива със стойността 0xff , тъй като Java представлява байт, използващ 8 бита и тъй като байт е подписан тип данни , стойността на 0xff е -1 :

byte y = (byte) 0xff; assertEquals(-1, y);

Както виждаме, когато дефинираме байтова променлива със стойността 0xff , трябва да я намалим до байт, тъй като обхватът на типа байтови данни е от -128 до 127 .

3. Често използване на операцията & 0xff

Най - оператор изпълнява на битовите и експлоатация . Изходът на битовото И е 1, ако съответните битове на два операнда са 1. От друга страна, ако някой от битовете на операндите е 0, резултатът от съответния бит се изчислява на 0.

От 0xff има осем такива през последните 8 бита , тя го прави прави идентичност елемент за побитова операция . Така че, ако приложим операцията x & 0xff , това ще ни даде най-ниските 8 бита от x . Забележете, че ако числото x е по-малко от 255, то ще остане същото. В противен случай това ще бъдат най-ниските 8 бита от x .

Като цяло операцията & 0xff ни предоставя лесен начин да извлечем най-ниските 8 бита от число . Всъщност можем да го използваме, за да извлечем всички 8 бита, от които се нуждаем, защото можем да изместим надясно всеки от 8-те бита, които искаме да бъдат най-ниските битове. След това можем да ги извлечем, като приложим операцията & 0xff .

Да видим пример, за да обясним някои от предимствата на използването на & 0xff по-подробно.

4. Извличане на RGBA цветни координати с помощта на & 0xff

Да приемем, че имаме цяло число x , съхранено в 32 бита, което представлява цвят в RGBA системата, което означава, че има 8 бита за всеки параметър (R, G, B и A):

  • R = 16 (00010000 в двоичен формат)
  • G = 57 (00111001 в двоичен формат)
  • B = 168 (10101000 в двоичен формат)
  • A = 7 (00000111 в двоичен формат)

И така, x в двоично би било представено като 00010000 00111001 10101000 00000111 - което е еквивалентно на 272214023 в десетичен знак.

Сега имаме стойността x в десетични знаци и искаме да извлечем стойността за всеки параметър.

Както знаем, операцията >> измества битовете надясно. Следователно, когато го направим (10000000 00000000 >> 8), това ни дава 10000000. В резултат на това можем да извлечем стойността на всеки параметър :

int rgba = 272214023; int r = rgba >> 24 & 0xff; assertEquals(16, r); int g = rgba >> 16 & 0xff; assertEquals(57, g); int b = rgba >> 8 & 0xff; assertEquals(168, b); int a = rgba & 0xff; assertEquals(7, a);

5. Заключение

В този урок обсъдихме как операцията & 0xff ефективно разделя променлива по начин, който оставя само стойността в последните 8 бита и игнорира останалите битове. Както видяхме, тази операция е особено полезна, когато сменим надясно променлива и трябва да извлечем изместените битове.

Както винаги, кодът, представен в тази статия, е достъпен в GitHub.