# Hvad er Java-bitvise operatorer, og hvordan bruges de? Med Java-bitvise operatorer kan du manipulere individuelle bits på enhver ønsket måde. De syv operatorer er opbygget på samme måde og følger faste regler, der er lette at lære. ## Hvad er bitvise operatorer, og hvad bruges de til? Java-operatorer er et vigtigt værktøj, når man arbejder med programmeringssproget. Ud over de mange andre muligheder og funktioner giver de dig mulighed for at manipulere de mindste mulige informationsenheder: bits. Bits (*binære cifre*) har deres eget talsystem baseret på værdierne 0 og 1. Hvis du vil forespørge binære værdier bit for bit, har du brug for en bitvis operator i Java. Du kan anvende dette på de **numeriske datatyper** (byte, char, int, short, long). Selvom du ikke har brug for funktionen til daglig, kan den være nyttig i mange situationer. Den kan for eksempel være praktisk, hvis du vil spare plads ved **konvertering af data**, hvis du vil bruge **XOR-operatoren**, eller hvis du **bare vil ændre en bit**. De er også grundlaget for alle højere kredsløbsoperationer. Derfor er det vigtigt at forstå den grundlæggende funktionalitet af Java-bitvise operatorer. ## Hvilke Java-bitvise operatorer findes der? Der er i alt syv forskellige bitvise operatorer i Java. For at få en helhedsforståelse starter vi med operanderne *a* og *b*. - **~ (bitvis NOT, komplement)**: Denne operator inverterer bits. Et 0 bliver til et 1, og et 1 bliver til et 0. - **& (bitvis AND)**: Denne operator udgiver en 1, hvis begge operander er 1. Ellers udgives en 0. - **| (bitvis OR)**: Denne operator producerer en 1, hvis en af de to operander også er 1. - **^ (XOR eller bitvis eksklusiv OR)**: Denne operator udgiver en 0, hvis begge operander har samme værdi. Ellers udgiver den en 1. - **<< (venstre skift)**: Denne operator skifter operanden *a* til venstre med *b* positioner. Hvis dette resulterer i mellemrum, udfyldes mellemrummene med 0. - **>> (højreskift med fortegn, aritmetisk)**: Denne operator skifter alle bits i *a* *b* positioner til højre. Hvis biten med den højeste værdi var indstillet før udførelsen, forbliver den indstillet bagefter. Negative tal forbliver negative. - **>>>> (usigneret højreskift, logisk)**: Denne operator skifter bitene i *a* til højre med *b* positioner. Mellemrum udfyldes altid med 0. ## Bitvis NOT Java-bitvisoperatøren bitvis NOT repræsenteres af en tilde (~). Den **negerer alle bits**, så nuller bliver til ettaller og ettaller bliver til nuller. Lad os tage tallet 20 som eksempel. I binær form ser det sådan ud: 10100. Hvis vi anvender bitwise NOT-operatoren, vil hver bit i tallet blive vendt: 10100 bliver til **01011**. Dette er værdien af udtrykket ~20. Hvis vi konverterer dette binære tal tilbage til et decimaltal, får vi værdien -21. Hvis du vil prøve denne proces i Java, skal du indtaste følgende kode og Java-kommandoen `System.out.println` for at få resultatet. ```java public class Main { public static void main(String[] args) { int value1 = 20; System.out.println(~value1); } } ``` Hvis du har indtastet alt korrekt, skal resultatet være ‘-21’. ## Bitvis AND Bitwise AND **sammenligner to tal i deres binære form** bit for bit. Den første bit i det første tal sammenlignes med den første bit i det andet tal, den anden med den anden bit og så videre. Hvis begge bits er 1, udgives en 1. Hvis dette ikke er tilfældet (begge bits er 0 eller en af bitsene er 0), udgives en 0. I eksemplet nedenfor ser vi på de to decimaltal 18 og 25. Som binærtal er 18 10010, og 25 i binær notation er 11001. Lad os nu sammenligne disse to tal og bestemme et tredje tal ud fra dem. 18 = 10010 25 = 11001 De to første bits i tallene er begge 1, så det resulterende tal starter også med 1. Den anden bit i 25 er også 1, men den anden bit i 18 er 0, hvilket gør cifret i det tredje tal til et 0. Efter at have gennemgået begge tal bit for bit, ender vi med det binære tal **10000**. Hvis vi konverterer dette til et decimaltal, bliver resultatet 16. Koden ser sådan ud: ```java public class Main { public static void main(String[] args) { System.out.println(18&25); } } ``` Outputtet i konsollen skal være 16. ## Bitvis OR Java-operatoren bitwise OR sammenligner også to tal bit for bit. I dette tilfælde skal dog kun den ene af de to operander have værdien 1 for at ende med resultatet 1. Hvis vi tager tallene fra det foregående eksempel, vil det se sådan ud: 18 = 10010 25 = 11001 Da alle bits undtagen det tredje ciffer indeholder mindst én 1, bliver det resulterende tal: **11011**. Omregnet får vi 27. Sådan ser dette eksempel ud i kode: ```java public class Main { public static void main(String[] args) { System.out.println(18|25); } } ``` ## XOR XOR eller bitvis eksklusiv OR (^) ligner bitvis OR. Med bitvis OR skal den ene eller begge operander være 1 for at give 1 som resultat. Med XOR gives der imidlertid kun 1 som resultat, hvis **nøjagtig én af de to værdier** er 1. For at få en bedre forståelse af, hvordan XOR fungerer, kan vi se på et eksempel: 18 = 10010 25 = 11001 De to første bits har værdien 1, så med denne bitvise operator i Java bliver resultatet 0. Den anden bit i 18 er 0, men den anden bit i 25 er 1. Dette giver værdien 1. Hvis vi fortsætter, får vi tallet **01011**. I decimalform er dette 11. Her er koden: ```java public class Main { public static void main(String[] args) { System.out.println(18^25); } } ``` ## Venstre skift Venstreforskydning forskydes værdien *a* til venstre med afstanden *b*. De resulterende **tomme felter udfyldes med 0**. En int-værdi, der optager 32 bits i en hukommelse, illustrerer dette tydeligt. Lad os tage tallet 20 eller 10010 for *a* igen og forskyd det med b-værdien 2 for at få c-værdien **1001000**. Der placeres to nuller i slutningen. 1001000 svarer til decimalværdien 72. Sådan ser denne proces ud i kode: ```java public class Main { public static void main(String[] args) { int a = 20; int b = 2; int c = (a << b); System.out.println(c); } } ``` ## Højre skift med tegn Højreskift fungerer omvendt. Her skiftes bits af værdien *a* til højre med værdien *b*, hvilket giver værdien c. Som følge heraf **udelades** de **sidste bits**. Hvis vi skifter 20 eller 10010 to pladser til højre, bliver resultatet **100** eller 4. Her er koden: ```java public class Main { public static void main(String[] args) { System.out.println(20 >> 2); } } ``` Det er vigtigt at bemærke, at hvis *a* er et positivt tal, udfyldes mellemrummene med 0. Hvis det er negativt, erstattes mellemrummene med 1. ## Højre skift uden tegn I princippet fungerer Java-bitvisoperatøren højreskift uden tegn (>>>) på samme måde. Den eneste forskel er, at de mellemrum, der opstår i venstre side ved skiftet til højre, **altid udfyldes med 0**. Dette resulterer altid i et positivt tal, selvom startværdien var negativ. This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-bitvise-operatorer/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-bitvise-operatorer/) for AI/LLM consumption.