# Kuidas kasutada Java modulo operaatorit

Kui jagamine ei õnnestu täielikult, jääb alles jääk. Java modulo operaator on mõeldud selle arvesse võtmiseks teie koodis. Operaator on oluliselt usaldusväärsem kui teised lahendused ja seda kasutatakse peamiselt selleks, et määrata, kas numbrid on paaris- või paaritud.

## Mis on Java modulo operaator?

Kõikides levinud programmeerimiskeeltes saab teha liitmise, lahutamise, korrutamise ja jagamise põhilisi aritmeetilisi tehteid. Java operaatorite abil saab kuvada ja lahendada ka keerukaid arvutusi. Eriti jagamise puhul on alati oht, et **jääb jääk**. Näiteks kui jagate 11 neljaga, jääb jäägiks 3 (*2 x 4 = 8, 11 - 8 = 3*). See võib programmeerimisel probleeme tekitada.

Selleks ongi Java modulo operaator. Seda tuntakse ka jäägi operaatorina, kuna see määrab ja tagastab **jäägi pärast kahe arvu jagamist**. On mitmeid olukordi, kus see on äärmiselt oluline. Operaatorit saab kasutada näiteks selleks, et teada saada, kas arv on paaris või paaritu või kas arv on algarv. Kuigi jääki on võimalik määrata ka muul viisil, jõuavad need viisid kiiresti oma piiridesse. Järgmine näide illustreerib seda.

## Milleks kasutatakse jäägi operaatorit?

Lihtsamalt öeldes tähendab jagamine seda, et kontrollitakse, mitu korda jagaja mahub jagatavasse. Tulemuseks on jagatis. Kui jagatav ja jagaja on mõlemad salvestatud [Java algandmetüübis](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-primitiivsed-tueuebid/) int (või täisarv), saab jäägi hõlpsasti väljendada ilma Java modulo abita. Kood näeks välja järgmine:

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

Seejärel saame tulemuse vaadata Java-käsu `System.out.println` abil:

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

See valik on veidi ebamugav, kuid teoreetiliselt võimalik. Siiski tekivad probleemid, kui vähemalt üks operand on float või double, st ujukomaarvuline andmetüüp. Sel juhul annab sama arvutus teistsuguse tulemuse:

```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
```

## Mis on modulo süntaks Java keeles?

Java modulo operaator aga annab alati **täpse jäägi**. See teostab jagamise, kuid näitab ainult jääki, mitte jagatist. See algatatakse protsendimärgiga, mis tähendab, et selle süntaks on järgmine:

```java
Dividend % Divisor
```

Java modulo näeks eespool toodud näites välja järgmine:

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

Väljund on siis:

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

## Kuidas kindlaks teha, kas number on paaritu või paaris

Java modulo abil saab teada, kas number on paaris või paaritu. See tuleneb lihtsast loogikast: kui jagad mis tahes numbri 2-ga ja jääk on 0, on number paaris. Muidu on number paaritu. Illustreerime seda **if-else-lause** abil.

```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.");
	}
	}
}
```

Nagu oodatud, saame järgmise tulemuse:

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

## Kuidas määrata negatiivse arvu jääk

Java modulo abil saab jäägi ka juhul, kui jagatav või jagaja on negatiivne. Siin on lihtne näide:

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

Kuna dividend on negatiivne, on ka jääk negatiivne:

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

Kuid alati ei pruugi soovida negatiivset tulemust. Kui soovite **saada positiivse jäägi**, võite koodi veidi muuta. Esmalt kontrollige, kas jääk on väiksem kui 0. Kui on, lisage jagaja ja saate positiivse jäägi. Kood näeb välja järgmine:

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

Saame järgmise väljundi:

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


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-moodul/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-moodul/) for AI/LLM consumption.