# Hvordan bruke Java-modulo-operatoren

Når divisjon ikke fungerer perfekt, blir du sittende igjen med en rest. Java-modulo-operatoren er der for å ta hensyn til dette i koden din. Operatoren er betydelig mer pålitelig enn andre løsninger og brukes primært til å avgjøre om tall er partall eller oddetall.

## Hva er Java-modulo-operatoren?

I alle vanlige programmeringsspråk kan du utføre de grunnleggende aritmetiske operasjonene addisjon, subtraksjon, multiplikasjon og divisjon. Du kan også bruke Java-operatorer til å vise og løse komplekse beregninger. Når det gjelder divisjon spesielt, er det alltid en risiko for at **det blir en rest**. Hvis du for eksempel deler 11 med 4, får du en rest på 3 (*2 x 4 = 8, 11 - 8 = 3*). Dette kan føre til problemer i programmeringen.

Det er det Java-modulo-operatoren er til for. Den er også kjent som restoperatoren, da den bestemmer og returnerer **resten etter at to tall er delt**. Det finnes ulike situasjoner der den er ekstremt viktig. Operator kan for eksempel brukes til å finne ut om et tall er partall eller oddetall, eller om et tall er et primtall. Selv om det også finnes andre måter å bestemme resten på, når de raskt sine grenser. Følgende eksempel illustrerer dette.

## Hva brukes restoperatøren til?

Enkelt sagt innebærer divisjon å sjekke hvor mange ganger en divisor passer inn i en dividende. Resultatet er kvotienten. Hvis dividenden og divisoren begge er lagret i den [primitive Java-datatypen](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-primitiver/) int (eller heltall), kan resten enkelt uttrykkes uten Java modulo. Koden vil se slik ut:

```java
public class Main {
	public static void main(String[] args) {
	int dividend = 11;
	int divisor = 4;
	int remainder = dividend - (divisor * (dividend / divisor));
	System.out.println("The remainder is: " + remainder);
	}
}
```

Vi kan deretter bruke Java-kommandoen `System.out.println` for å se resultatet:

```java
The remainder is: 3
```

Dette alternativet er litt tungvint, men er i teorien mulig. Vi vil imidlertid støte på problemer så snart minst én av operandene er en float eller double, det vil si en flytende talltype. I dette tilfellet vil den samme beregningen gi oss et annet resultat:

```java
public class Main {
	public static void main(String[] args) {
	int dividend = 11;
	double divisor = 4;
	double remainder = dividend - (divisor * (dividend / divisor));
	System.out.println("The remainder is: " + remainder);
	}
}
```

```java
The remainder is: 0.0
```

## Hva er syntaksen for modulo i Java?

Java-modulo-operatoren, derimot, vil alltid returnere den **eksakte resten**. Den utfører divisjon, men viser bare resten, ikke kvotienten. Den initialiseres med et prosenttegn, noe som betyr at syntaksen ser slik ut:

```java
Dividend % Divisor
```

Java modulo vil se slik ut når det brukes i eksemplet ovenfor:

```java
public class Main {
	public static void main(String[] args) {
	int dividend = 11;
	double divisor = 4;
	double remainder = dividend % divisor;
	System.out.println("The remainder is: " + remainder);
	}
}
```

Resultatet blir da:

```java
The remainder is: 3.0
```

## Hvordan finne ut om et tall er oddetall eller partall

Java modulo kan brukes til å finne ut om et tall er partall eller oddetall. Det følger av enkel logikk: Hvis du deler et tall med 2 og resten er 0, er det partall. Ellers er det oddetall. Vi illustrerer dette med en **if-else-setning**.

```java
public class Main {
	public static void main(String[] args) {
	int dividend = 11;
	if (dividend % 2 == 0) {
	System.out.println(dividend + " is an even number.");
	}
	else {
	System.out.println(dividend + " is an odd number.");
	}
	}
}
```

Som forventet får vi følgende resultat:

```java
11 is an odd number.
```

## Hvordan bestemme resten av et negativt tall

Du kan også bruke Java modulo for å få resten når dividenden eller divisoren er negativ. Her er et enkelt eksempel:

```java
public class Main {
	public static void main(String[] args) {
	int dividend = -11;
	int divisor = 4;
	int remainder = dividend % divisor;
	System.out.println("The remainder is: " + remainder);
	}
}
```

Siden utbyttet er negativt, er også resten negativt:

```java
The remainder is: -3
```

Men det er ikke alltid du ønsker å få et negativt resultat. Hvis du vil **returnere en positiv rest**, kan du endre koden litt. Sjekk først om resten er mindre enn 0. Hvis det er tilfelle, legger du til divisoren, og du får den positive resten. Slik ser koden ut:

```java
public class Main {
	public static void main(String[] args) {
	int dividend = -11;
	int divisor = 4;
	int remainder = dividend % divisor;
	System.out.println("The remainder before is: " + remainder);
	while (dividend < 0) dividend += divisor;
	int positive_remainder = dividend % divisor;
	System.out.println("The remainder after is: " + positive_remainder);
	}
}
```

Vi får følgende utdata:

```java
The remainder before is: -3
The remainder after is: 1
```


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