Forstå & 0xff-verdien i Java

1. Oversikt

0xffer et tall representert iheksadesimalt tallsystem (base 16). Den består av to F tall i hex. Som vi vet, F i hex tilsvarer 1111 i det binære tallsystemet. Så, 0xff i binær er 11111111.

I denne artikkelen vil vi oppdage hvordan du bruker 0xff verdi. I tillegg får vi se hvordan du kan representere den ved hjelp av flere datatyper og hvordan du bruker den med & operatør. Til slutt vil vi gjennomgå noen av fordelene knyttet til bruk av den.

2. Representerer 0xff Med forskjellige datatyper

Java lar oss definere tall tolket som hex (base 16) ved å bruke 0x prefiks, etterfulgt av et heltall bokstavelig.

Verdien 0xff tilsvarer 255 i usignert desimal, -127 i signert desimal og 11111111 i binær.

Så hvis vi definerer en int variabel med verdien på 0xff, siden Java representerer heltall med 32 bits, verdien av 0xff er 255:

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

Imidlertid, hvis vi definerer en byte variabel med verdien 0xff, siden Java representerer en byte som bruker 8 bits, og fordi en byte er en signert datatype, verdien av 0xff er -1:

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

Som vi ser, når vi definerer en byte variabel med 0xff verdi, må vi nedstøte den til en byte fordi rekkevidden til byte datatype er fra -128 til 127.

3. Vanlig bruk av & 0xff Operasjon

De & operatøren utfører bitvis OG-operasjon. Utgangen fra bitvis AND er 1 hvis de tilsvarende bitene i to operander er 1. På den annen side, hvis hver bit av operandene er 0, blir resultatet av den tilsvarende biten evaluert til 0.

Siden 0xff har åtte de siste 8 bitene, det gjør det til et identitetselement for bitvis OG-operasjon. Så hvis vi bruker x & 0xff operasjon, det vil gi oss de laveste 8 bitene fra x. Legg merke til at hvis nummeret x er mindre enn 255, vil det fortsatt være det samme. Ellers vil det være de laveste 8 bitene fra x.

Generelt sett & 0xff operasjonen gir oss en enkel måte å trekke ut de laveste 8 bitene fra et tall. Vi kan faktisk bruke den til å trekke ut hvilke 8 biter vi trenger fordi vi kan skifte til høyre hvilken som helst av de 8 bitene vi vil være de laveste bitene. Deretter kan vi trekke dem ut ved å bruke & 0xff operasjon.

La oss se et eksempel for å forklare noen av fordelene ved bruk & 0xff i mer detalj.

4. Pakke ut RGBA-fargekoordinater ved hjelp av & 0xff

La oss anta at vi har et heltall x, lagret i 32 bits, som representerer en farge i RGBA-systemet, noe som betyr at den har 8 bits for hver parameter (R, G, B og A):

  • R = 16 (00010000 i binær)
  • G = 57 (00111001 i binær)
  • B = 168 (10101000 i binær)
  • A = 7 (00000111 i binær)

Så, x i binær vil bli representert som 00010000 00111001 10101000 00000111 - som tilsvarer 272214023 i desimal.

Nå har vi vår x verdi i desimal, og vi vil trekke ut verdien for hver parameter.

Som vi vet skifter >> operasjonen biter til høyre. Derfor, når vi gjør det (10000000 00000000 >> 8), gir det oss 10000000. Som et resultat kan vi trekke ut verdien av hver parameter:

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. Konklusjon

I denne opplæringen har vi diskutert hvordan & 0xff operasjon deler effektivt en variabel på en måte som bare etterlater verdien i de siste 8 bitene og ignorerer resten av bitene. Som vi har sett, er denne operasjonen spesielt nyttig når vi skifter til høyre en variabel og trenger å trekke ut de skiftede bitene.

Som alltid er koden presentert i denne artikkelen tilgjengelig på GitHub.