Wat zijn Java bitwise operators en hoe gebruik je ze?
Met Java bitwise operators kunt u individuele bits op elke gewenste manier manipuleren. De zeven operators zijn op dezelfde manier gestructureerd en volgen vaste regels die gemakkelijk te leren zijn.
Wat zijn bitwise operatoren en waarvoor worden ze gebruikt?
Java-operatoren zijn een belangrijk hulpmiddel bij het werken met de programmeertaal. Naast de vele andere mogelijkheden en functies bieden ze u de mogelijkheid om de kleinst mogelijke informatie-eenheden te manipuleren: bits. Bits (binaire cijfers) hebben hun eigen getallenstelsel op basis van de waarden 0 en 1. Als u binaire waarden bit voor bit wilt opvragen, hebt u een bitwise operator in Java nodig. U kunt deze toepassen op de numerieke gegevenstypen (byte, char, int, short, long).
Hoewel u deze functie niet dagelijks nodig zult hebben, kan deze in veel situaties nuttig zijn. Het kan bijvoorbeeld handig zijn als u ruimte wilt besparen bij het converteren van gegevens, als u de XOR-operator wilt gebruiken of als u gewoon een bit wilt wijzigen. Ze vormen ook de basis voor alle hogere circuitbewerkingen. Daarom is het belangrijk om de basisfunctionaliteit van Java-bitwise-operatoren te begrijpen.
Welke Java-bitwise-operatoren zijn er?
Er zijn in totaal zeven verschillende bitwise operatoren in Java. Om een volledig begrip te krijgen, beginnen we met de operanden a en b.
- ~ (bitgewijze NOT, complement): Deze operator keert bits om. Een 0 wordt een 1 en een 1 wordt een 0.
- & (bitgewijze AND): Deze operator geeft een 1 weer als beide operanden 1 zijn. Anders wordt een 0 weergegeven.
- | (bitgewijze OR): Deze operator produceert een 1 als een van de twee operanden ook 1 is.
- ^ (XOR of bitgewijze exclusieve OR): Deze operator geeft een 0 uit als beide operanden dezelfde waarde hebben. Anders geeft hij een 1 uit.
- << (links verschuiven): Deze operator verschuift operand a b posities naar links. Als dit resulteert in spaties, worden de spaties opgevuld met 0.
- >> (rechts verschuiven met teken, rekenkundig): Deze operator verschuift alle bits van a met b posities naar rechts. Als de bit met de hoogste waarde vóór de uitvoering was ingesteld, blijft deze daarna ingesteld. Negatieve getallen blijven negatief.
- >>>> (rechts verschuiven zonder teken, logisch): Deze operator verschuift de bits van a met b posities naar rechts. Spaties worden altijd opgevuld met 0.
Bitgewijze NOT
De Java bitwise operator bitwise NOT wordt weergegeven door een tilde (~). Deze negeert alle bits, waardoor nullen worden omgezet in enen en enen in nullen. Laten we bijvoorbeeld het getal 20 nemen. In binair ziet dit er als volgt uit: 10100. Als we de bitwise NOT-operator toepassen, wordt elke bit van het getal omgedraaid: 10100 wordt 01011. Dit is de waarde van de uitdrukking ~20. Als we dit binaire getal weer omzetten naar een decimaal getal, krijgen we de waarde -21. Als je dit proces in Java wilt uitproberen, voer dan de volgende code en het Java-commando System.out.println in om het resultaat weer te geven.
public class Main {
public static void main(String[] args) {
int value1 = 20;
System.out.println(~value1);
}
}Als je alles correct hebt ingevoerd, zou de uitvoer ‘-21’ moeten zijn.
Bitgewijze AND
Bitwise AND vergelijkt twee getallen in hun binaire vorm bit voor bit. De eerste bit van het eerste getal wordt vergeleken met de eerste bit van het tweede getal, de tweede met de tweede bit, enzovoort. Als beide bits 1 zijn, wordt een 1 uitgevoerd. Als dit niet het geval is (beide bits zijn 0 of een van de bits is 0), wordt een 0 uitgevoerd. In het onderstaande voorbeeld bekijken we de twee decimale getallen 18 en 25. Als binair getal is 18 10010 en 25 in binaire notatie is 11001. Laten we nu deze twee getallen vergelijken en daaruit een derde getal bepalen.
18 = 10010 25 = 11001
De eerste twee bits in de getallen zijn beide 1, dus het resulterende getal begint ook met 1. De tweede bit van 25 is ook 1, maar de tweede bit van 18 is 0, waardoor het cijfer in het derde getal een 0 wordt. Nadat we beide getallen bit voor bit hebben doorlopen, komen we uit op het binaire getal 10000. Als we dit omzetten naar een decimaal getal, is de uitkomst 16.
De code ziet er als volgt uit:
public class Main {
public static void main(String[] args) {
System.out.println(18&25);
}
}De uitvoer in de console moet 16 zijn.
Bitgewijze OR
De Java-operator bitwise OR vergelijkt ook twee getallen bit voor bit. In dit geval hoeft echter slechts één van de twee operanden de waarde 1 te hebben om het resultaat 1 te krijgen. Als we de getallen uit het vorige voorbeeld nemen, ziet dat er als volgt uit:
18 = 10010 25 = 11001
Aangezien alle bits behalve het derde cijfer ten minste één 1 bevatten, is het resulterende getal: 11011. Omgerekend krijgen we 27.
Zo ziet dit voorbeeld eruit in code:
public class Main {
public static void main(String[] args) {
System.out.println(18|25);
}
}XOR
XOR of bitgewijze exclusieve OR (^) is vergelijkbaar met bitgewijze OR. Bij bitgewijze OR moeten één of beide operanden 1 zijn om 1 als uitvoer te krijgen. Bij XOR wordt echter alleen een 1 als uitvoer gegeven als precies één van de twee waarden 1 is. Om een beter beeld te krijgen van hoe XOR werkt, kijken we naar een voorbeeld:
18 = 10010 25 = 11001
De eerste twee bits hebben de waarde 1, dus met deze bitgewijze operator in Java is het resultaat 0. De tweede bit van 18 is 0, maar de tweede bit van 25 is 1. Dit resulteert in de waarde 1. Als we doorgaan, krijgen we het getal 01011. In decimale vorm is dit 11.
Hier is de code:
public class Main {
public static void main(String[] args) {
System.out.println(18^25);
}
}Links verschuiven
Links verschuiven verschuift de bits van waarde a naar links met de afstand b. De resulterende lege plekken worden opgevuld met 0. Een int-waarde die 32 bits in een geheugen inneemt, illustreert dit duidelijk. Laten we opnieuw het getal 20 of 10010 nemen en dit verschuiven met de b-waarde 2 om de c-waarde 1001000 te krijgen. Aan het einde worden twee nullen geplaatst. 1001000 komt overeen met de decimale waarde 72.
Zo ziet dit proces er in code uit:
public class Main {
public static void main(String[] args) {
int a = 20;
int b = 2;
int c = (a << b);
System.out.println(c);
}
}Rechterverschuiving met teken
Rechts verschuiven werkt andersom. Hier worden bits van de waarde a met de waarde b naar rechts verschoven, wat de waarde c oplevert. Als gevolg hiervan worden de laatste bits weggelaten. Als we 20 of 10010 twee plaatsen naar rechts verschuiven, is het resultaat 100 of 4.
Hier is de code:
public class Main {
public static void main(String[] args) {
System.out.println(20 >> 2);
}
}Het is belangrijk om op te merken dat als a een positief getal is, de spaties worden opgevuld met 0. Als het negatief is, worden de spaties vervangen door 1.
Rechterverschuiving zonder teken
In principe werkt de Java bitwise operator rechts verschuiven zonder teken (>>>) op dezelfde manier. Het enige verschil is dat de ruimtes die aan de linkerkant ontstaan door de verschuiving naar rechts altijd worden opgevuld met 0. Dit resulteert altijd in een positief getal, zelfs als de startwaarde negatief was.