# Java-modulo-operaattorin käyttö

Kun jakaminen ei onnistu täydellisesti, jää jäljelle jäännös. Java-modulo-operaattori on olemassa ottamaan tämä huomioon koodissasi. Operaattori on huomattavasti luotettavampi kuin muut ratkaisut, ja sitä käytetään pääasiassa määrittämään, ovatko luvut parillisia vai parittomia.

## Mikä on Java-modulo-operaattori?

Kaikissa yleisissä ohjelmointikielissä voit suorittaa peruslaskutoimituksia, kuten yhteenlaskua, vähennyslaskua, kertolaskua ja jakolaskua. Voit myös käyttää Java-operaattoreita monimutkaisten laskelmien näyttämiseen ja ratkaisemiseen. Erityisesti jakolaskuissa on aina riski, että **jää jäännös**. Esimerkiksi, jos jaat 11 neljällä, jäännös on 3 (*2 x 4 = 8, 11 - 8 = 3*). Tämä voi aiheuttaa ongelmia ohjelmoinnissa.

Sitä varten on Java-modulo-operaattori. Se tunnetaan myös nimellä jäännösoperaattori, koska se määrittää ja palauttaa **kahden luvun jakamisen jälkeisen jäännöksen**. On monia tilanteita, joissa se on erittäin tärkeä. Operaattoria voidaan käyttää esimerkiksi selvittämään, onko luku parillinen vai pariton tai onko luku alkuluku. On myös muita tapoja määrittää jäännös, mutta ne saavuttavat nopeasti rajansa. Seuraava esimerkki havainnollistaa tätä.

## Mihin jäännösoperaattoria käytetään?

Yksinkertaisesti sanottuna jakaminen tarkoittaa sen tarkistamista, kuinka monta kertaa jakaja mahtuu jaettavaan. Tuloksena on osamäärä. Jos jaettava ja jakaja on molemmat tallennettu [Java-primitiiviseen tietotyyppiin](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-primitiivit/) int (tai kokonaisluku), jäännös voidaan helposti ilmaista ilman Java-moduloa. Koodi näyttäisi seuraavalta:

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

Voimme sitten käyttää Java-komentoa `System.out.println` tuloksen tarkastelemiseen:

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

Tämä vaihtoehto on hieman hankala, mutta teoriassa mahdollista. Ongelmia syntyy kuitenkin heti, kun vähintään yksi operandeista on float- tai double-tyyppinen, eli liukulukuinen tietotyyppi. Tällöin sama laskutoimitus antaa eri tuloksen:

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

## Mikä on modulo-sanan syntaksi Java-kielessä?

Java-modulo-operaattori puolestaan palauttaa aina **tarkan jäännöksen**. Se suorittaa jakolaskun, mutta näyttää vain jäännöksen, ei osamäärää. Se alustetaan prosenttimerkillä, joten sen syntaksi on seuraava:

```java
Dividend % Divisor
```

Java-modulo näyttäisi seuraavalta, kun sitä käytetään yllä olevassa esimerkissä:

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

Tuloksena on sitten:

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

## Kuinka määrittää, onko luku pariton vai parillinen

Java-modulo-funktiota voidaan käyttää selvittämään, onko luku parillinen vai pariton. Se perustuu yksinkertaiseen logiikkaan: jos jaat minkä tahansa luvun kahdella ja jäännös on 0, luku on parillinen. Muussa tapauksessa se on pariton. Havainnollistamme tätä **if-else-lauseella**.

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

Kuten odotettua, saamme seuraavan tuloksen:

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

## Kuinka määrittää negatiivisen luvun jäännös

Voit myös käyttää Java-modulo-funktiota saadaksesi jäännöksen, kun jaettava tai jakaja on negatiivinen. Tässä on yksinkertainen esimerkki:

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

Koska osinko on negatiivinen, myös jäljelle jäävä osa on negatiivinen:

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

Mutta et ehkä aina halua saada negatiivista tulosta. Jos haluat **palauttaa positiivisen jäännöksen**, voit muokata koodia hieman. Tarkista ensin, onko jäännös pienempi kuin 0. Jos on, lisää jakaja ja saat positiivisen jäännöksen. Koodi näyttää seuraavalta:

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

Saamme seuraavan tuloksen:

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


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-modulo/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-modulo/) for AI/LLM consumption.