Hur man använder Java-modulo-operatorn

När di­vi­sio­nen inte fungerar perfekt blir det en rest. Java-modulo-operatorn finns till för att ta hänsyn till detta i din kod. Ope­ra­tö­ren är betydligt mer till­för­lit­lig än andra lösningar och används främst för att avgöra om tal är jämna eller udda.

Vad är Java-modulo-operatorn?

I alla vanliga pro­gram­me­rings­språk kan du utföra de grund­läg­gan­de arit­me­tis­ka ope­ra­tio­ner­na addition, sub­trak­tion, mul­ti­pli­ka­tion och division. Du kan också använda Java-ope­ra­to­rer för att visa och lösa komplexa be­räk­ning­ar. När det gäller division finns det alltid en risk att det blir en rest. Om du till exempel delar 11 med 4 får du en rest på 3 (2 x 4 = 8, 11 - 8 = 3). Detta kan leda till problem vid pro­gram­me­ring.

Det är vad Java-modulo-operatorn är till för. Den kallas också resto­pe­ra­torn, eftersom den bestämmer och re­tur­ne­rar resten efter att två tal har di­vi­de­rats. Det finns olika si­tu­a­tio­ner där den är extremt viktig. Ope­ra­tö­ren kan till exempel användas för att ta reda på om ett tal är jämnt eller udda eller om ett tal är ett primtal. Det finns också andra sätt att bestämma resten, men de når snabbt sina gränser. Följande exempel il­lu­stre­rar detta.

Vad används resto­pe­ra­torn till?

Enkelt uttryckt innebär division att man kon­trol­le­rar hur många gånger en divisor passar in i en dividend. Re­sul­ta­tet är kvoten. Om både di­vi­den­den och divisorn lagras i den primitiva Java-datatypen int (eller heltal) kan resten enkelt uttryckas utan Java-modulo. Koden skulle se ut så här:

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 sedan använda Java-kommandot System.out.println för att visa re­sul­ta­tet:

The remainder is: 3

Det här al­ter­na­ti­vet är lite krångligt, men i teorin är det möjligt. Men vi stöter på problem så fort minst en av ope­ran­der­na är en float eller double, det vill säga en flytande datatyp. I det här fallet ger samma beräkning ett annat resultat:

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);
	}
}

The remainder is: 0.0

Vad är syntaxen för modulo i Java?

Java-modulo-operatorn å andra sidan re­tur­ne­rar alltid den exakta resten. Den utför division men visar endast resten, inte kvoten. Den ini­ti­a­li­se­ras med ett pro­cent­tec­ken, vilket innebär att dess syntax ser ut som följer:

Dividend % Divisor

Java-modulo skulle se ut som följer när det används i exemplet ovan:

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);
	}
}

Re­sul­ta­tet blir då:

The remainder is: 3.0

Hur man avgör om ett tal är udda eller jämnt

Java modulo kan användas för att ta reda på om ett tal är jämnt eller udda. Det följer av enkel logik: Om du delar ett tal med 2 och resten är 0, är det jämnt. Annars är det udda. Vi il­lu­stre­rar detta med ett if-else-uttryck.

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 förväntat får vi följande resultat:

11 is an odd number.

Hur man beräknar resten av ett negativt tal

Du kan också använda Java modulo för att få resten när di­vi­den­den eller divisorn är negativ. Här är ett enkelt exempel:

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);
	}
}

Eftersom ut­del­ning­en är negativ är även resten negativ:

The remainder is: -3

Men du kanske inte alltid vill få ett negativt resultat. Om du vill returnera en positiv rest kan du ändra koden lite. Kon­trol­le­ra först om resten är mindre än 0. Om så är fallet, lägg till delaren så får du den positiva resten. Så här ser koden ut:

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öljande utdata:

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