# Hva er Java-bitvise operatører og hvordan bruker man dem?

Med Java-bitvise operatører kan du manipulere individuelle biter på hvilken som helst måte du ønsker. De syv operatørene er strukturert på samme måte og følger faste regler som er enkle å lære.

## Hva er bitvise operatører, og hva brukes de til?

Java-operatorer er et viktig verktøy når du arbeider med programmeringsspråket. I tillegg til de mange andre mulighetene og funksjonene, gir de deg muligheten til å manipulere de minste mulige informasjonsenhetene: biter. Biter (*binære sifre*) har sitt eget tallsystem basert på verdiene 0 og 1. Hvis du vil spørre om binære verdier bit for bit, trenger du en bitvis operatør i Java. Du kan bruke dette på de **numeriske datatypene** (byte, char, int, short, long).

Selv om du ikke trenger funksjonen til daglig, kan den være nyttig i mange situasjoner. Den kan for eksempel være praktisk hvis du vil spare plass når **du konverterer data**, hvis du vil bruke **XOR-operatoren** eller hvis du **bare vil endre en bit**. De er også grunnlaget for alle høyere kretsoperasjoner. Derfor er det viktig å forstå den grunnleggende funksjonaliteten til Java-bitvise operatorer.

## Hvilke bitvise operatører finnes det i Java?

Det finnes totalt syv forskjellige bitvise operatorer i Java. For å få en helhetlig forståelse, begynner vi med operandene *a* og *b*.

- **~ (bitvis NOT, komplement)**: Denne operatoren inverterer biter. En 0 blir en 1 og en 1 blir en 0.
- **& (bitvis AND)**: Denne operatoren gir ut en 1 hvis begge operandene er 1. Ellers blir det gitt ut en 0.
- **| (bitvis OR)**: Denne operatoren gir 1 hvis en av de to operandene også er 1.
- **^ (XOR eller bitvis eksklusiv OR)**: Denne operatoren gir ut en 0 hvis begge operandene har samme verdi. Ellers gir den ut en 1.
- **<< (venstreforskyvning)**: Denne operatoren forskyver operanden *a* til venstre med *b* posisjoner. Hvis dette resulterer i mellomrom, fylles mellomrommene med 0.
- **>> (høyreforskyvning med fortegn, aritmetisk)**: Denne operatoren forskyver alle bitene i *a* med *b* posisjoner til høyre. Hvis biten med den høyeste verdien var satt før utførelsen, forblir den satt etterpå. Negative tall forblir negative.
- **>>>> (usignert høyreforskyvning, logisk)**: Denne operatoren forskyver bitene i *a* til høyre med *b* posisjoner. Mellomrom fylles alltid med 0.

## Bitvis NOT

Java-bitvisoperatøren bitvis NOT representeres av en tilde (~). Den **negerer alle biter**, og gjør nuller til ettall og ettall til nuller. La oss ta tallet 20 som eksempel. I binær form ser det slik ut: 10100. Hvis vi bruker bitvis NOT-operatoren, vil hver bit i tallet byttes om: 10100 blir **01011**. Dette er verdien av uttrykket ~20. Hvis vi konverterer dette binære tallet tilbake til et desimaltall, får vi verdien -21. Hvis du vil prøve denne prosessen i Java, skriver du inn følgende kode og Java-kommandoen `System.out.println` for å vise resultatet.

```java
public class Main {
	public static void main(String[] args) {
	int value1 = 20;
	System.out.println(~value1);
}
}
```

Hvis du har skrevet inn alt riktig, skal resultatet være «-21».

## Bitvis AND

Bitvis AND **sammenligner to tall i binær form** bit for bit. Den første biten i det første tallet sammenlignes med den første biten i det andre tallet, den andre med den andre biten og så videre. Hvis begge bitene er 1, blir resultatet 1. Hvis dette ikke er tilfelle (begge bitene er 0 eller en av bitene er 0), blir resultatet 0. I eksemplet nedenfor skal vi se på de to desimaltallene 18 og 25. Som binærtall er 18 10010, og 25 i binær notasjon er 11001. La oss nå sammenligne disse to tallene og bestemme et tredje tall ut fra dem.

18 = 10010 25 = 11001

De to første bitene i tallene er begge 1, så det resulterende tallet starter også med 1. Den andre biten i 25 er også 1, men den andre biten i 18 er 0, noe som gjør at sifferet i det tredje tallet blir 0. Etter å ha gått gjennom begge tallene bit for bit, ender vi opp med binærtallet **10000**. Hvis vi konverterer dette til et desimaltall, blir resultatet 16.

Koden ser slik ut:

```java
public class Main {
	public static void main(String[] args) {
	System.out.println(18&25);
}
}
```

Utdataene i konsollen skal være 16.

## Bitvis OR

Java-operatoren bitvis OR sammenligner også to tall bit for bit. I dette tilfellet må imidlertid bare én av de to operandene ha verdien 1 for å ende opp med resultatet 1. Hvis vi tar tallene fra forrige eksempel, vil det se slik ut:

18 = 10010 25 = 11001

Siden alle biter unntatt den tredje sifferet inneholder minst én 1, blir det resulterende tallet: **11011**. Konvertert får vi 27.

Slik ser dette eksemplet ut i koden:

```java
public class Main {
	public static void main(String[] args) {
	System.out.println(18|25);
}
}
```

## XOR

XOR eller bitvis eksklusiv OR (^) ligner på bitvis OR. Med bitvis OR må én eller begge operandene være 1 for å gi utdata 1. Med XOR blir imidlertid 1 bare gitt ut hvis **nøyaktig én av de to verdiene** er 1. For å få en bedre forståelse av hvordan XOR fungerer, kan vi se på et eksempel:

18 = 10010 25 = 11001

De to første bitene har verdien 1, så med denne bitvise operatøren i Java blir resultatet 0. Den andre biten av 18 er 0, men den andre biten av 25 er 1. Dette gir verdien 1. Hvis vi fortsetter, får vi tallet **01011**. I desimalform er dette 11.

Her er koden:

```java
public class Main {
	public static void main(String[] args) {
	System.out.println(18^25);
}
}
```

## Venstre skift

Venstreforskyvning forskyver bitene i verdien *a* til venstre med avstanden *b*. De resulterende **tomrommene fylles med 0**. En int-verdi som opptar 32 bit i minnet illustrerer dette tydelig. La oss ta tallet 20 eller 10010 for *a* igjen og forskyve det med b-verdien 2 for å få c-verdien **1001000**. To nuller plasseres på slutten. 1001000 tilsvarer desimalverdien 72.

Slik ser denne prosessen ut i koden:

```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øyreforskyvning med fortegn

Høyreforskyvning fungerer motsatt. Her forskyves bitene i verdien *a* til høyre med verdien *b*, noe som gir verdien c. Som et resultat **blir** de **siste bitene utelatt**. Hvis vi forskyver 20 eller 10010 to plasser til høyre, blir resultatet **100** eller 4.

Her er koden:

```java
public class Main {
	public static void main(String[] args) {
	System.out.println(20 >> 2);
}
}
```

Det er viktig å merke seg at hvis *a* er et positivt tall, fylles mellomrommene med 0. Hvis det er negativt, erstattes mellomrommene med 1.

## Høyre skift uten tegn

I prinsippet fungerer Java-bitvisoperatøren høyreforskyvning uten tegn (&gt;&gt;&gt;) på samme måte. Den eneste forskjellen er at mellomrommene som oppstår på venstre side ved forskyvningen til høyre, **alltid fylles med 0**. Dette resulterer alltid i et positivt tall, selv om startverdien var negativ.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-bitvise-operatoerer/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-bitvise-operatoerer/) for AI/LLM consumption.