Inzicht in de & 0xff-waarde in Java

1. Overzicht

0xffis een getal vertegenwoordigd in dehexadecimaal cijfersysteem (basis 16). Het is samengesteld uit twee F. cijfers in hex. Zoals we weten, F. in hex komt overeen met 1111 in het binaire cijfersysteem. Zo, 0xff in binair is 11111111.

In dit artikel zullen we ontdekken hoe u de 0xff waarde. Daarnaast zullen we zien hoe u deze kunt weergeven met behulp van meerdere gegevenstypen en hoe u deze kunt gebruiken met de & operator. Ten slotte bespreken we enkele van de voordelen die aan het gebruik ervan zijn verbonden.

2. Vertegenwoordigen 0xff Met verschillende gegevenstypen

Met Java kunnen we getallen definiëren die worden geïnterpreteerd als hexadecimaal (basis 16) door de 0x prefix, gevolgd door een geheel getal letterlijk.

De waarde 0xff is gelijk aan 255 in decimaal zonder teken, -127 in decimaal met teken en 11111111 in binair getal.

Dus als we een int variabele met een waarde van 0xff, sinds Java vertegenwoordigt gehele getallen met 32 ​​bits, de waarde van 0xff is 255:

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

Als we echter een byte variabele met de waarde 0xff, aangezien Java een byte vertegenwoordigt die 8 bits gebruikt en omdat een byte een ondertekend gegevenstype is, de waarde van 0xff is -1:

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

Zoals we zien, wanneer we een byte variabele met de 0xff waarde, we moeten het downcasten naar een byte omdat het bereik van de byte gegevenstype is van -128 tot 127.

3. Algemeen gebruik van & 0xff Operatie

De & operator voert een bitsgewijze EN-bewerking uit. De uitvoer van bitsgewijze AND is 1 als de corresponderende bits van twee operanden 1 is. Aan de andere kant, als een van de bits van de operanden 0 is, wordt het resultaat van de corresponderende bit geëvalueerd naar 0.

Sinds 0xff heeft acht enen in de laatste 8 bits, het maakt het een identiteitselement voor de bitsgewijze EN-bewerking. Dus als we de x & 0xff operatie, het geeft ons de laagste 8 bits van X. Merk op dat, als het nummer X minder is dan 255, zal het nog steeds hetzelfde zijn. Anders zijn het de laagste 8 bits van X.

In het algemeen is de & 0xff operatie biedt ons een eenvoudige manier om de laagste 8 bits uit een getal te extraheren. We kunnen het eigenlijk gebruiken om elke 8 bits die we nodig hebben te extraheren, omdat we elk van de 8 bits naar rechts kunnen verschuiven waarvan we de laagste bits willen zijn. Vervolgens kunnen we ze extraheren door de & 0xff operatie.

Laten we een voorbeeld bekijken om enkele voordelen van het gebruik uit te leggen & 0xff meer gedetailleerd.

4. RGBA-kleurcoördinaten extraheren met & 0xff

Laten we aannemen dat we een geheel getal hebben X, opgeslagen in 32 bits, die een kleur in het RGBA-systeem vertegenwoordigt, wat betekent dat het 8 bits heeft voor elke parameter (R, G, B en A):

  • R = 16 (00010000 in binair)
  • G = 57 (00111001 in binair)
  • B = 168 (10101000 in binair)
  • A = 7 (00000111 in binair)

Zo, X in binair zou worden weergegeven als 00010000 00111001 10101000 00000111 - wat het equivalent is van 272214023 in decimaal.

Nu hebben we onze X waarde in decimaal, en we willen de waarde voor elke parameter extraheren.

Zoals we weten, verschuift de bewerking >> bits naar rechts. Daarom, als we dat doen (10000000 00000000 >> 8), geeft het ons 10000000. Als resultaat kunnen we de waarde van elke parameter extraheren:

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

In deze zelfstudie hebben we besproken hoe de & 0xff bewerking verdeelt effectief een variabele op een manier die alleen de waarde in de laatste 8 bits overlaat en de rest van de bits negeert. Zoals we hebben gezien, is deze bewerking vooral handig wanneer we een variabele naar rechts schuiven en de verschoven bits moeten extraheren.

Zoals altijd is de code die in dit artikel wordt gepresenteerd, beschikbaar op GitHub.