# Kā lietot Java modulo operatoru

Ja dalīšana neizdodas perfekti, paliek atlikums. Java modulo operators ir paredzēts, lai to ņemtu vērā jūsu kodā. Operators ir ievērojami uzticamāks nekā citi risinājumi un galvenokārt tiek izmantots, lai noteiktu, vai skaitļi ir pāra vai nepāra.

## Kas ir Java modulo operators?

Visās izplatītākajās programmēšanas valodās var veikt pamata aritmētiskās darbības: saskaitīšanu, atņemšanu, reizināšanu un dalīšanu. Ar Java operatoriem var arī attēlot un risināt sarežģītus aprēķinus. Jo īpaši dalīšanas gadījumā vienmēr pastāv risks, ka **paliks atlikums**. Piemēram, ja dalāt 11 ar 4, atlikums būs 3 (*2 x 4 = 8, 11 - 8 = 3*). Tas var radīt problēmas programmēšanā.

Tieši tam paredzēts Java modulo operators. To sauc arī par atlikuma operatoru, jo tas nosaka un atgriež **atlikumu pēc divu skaitļu dalīšanas**. Ir dažādas situācijas, kurās tas ir ļoti svarīgi. Operatoru var izmantot, piemēram, lai noskaidrotu, vai skaitlis ir pāra vai nepāra, vai arī vai skaitlis ir pirmskaitlis. Lai gan ir arī citi veidi, kā noteikt atlikumu, tie ātri sasniedz savas robežas. To ilustrē šis piemērs.

## Kādam nolūkam tiek izmantots atlikuma operators?

Vienkārši runājot, dalīšana nozīmē pārbaudīt, cik reizes dalītājs ietilpst dalāmajā. Rezultāts ir dalījuma rezultāts. Ja dalāmais un dalītājs ir abi saglabāti [primitīvā Java datu tipā](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-primitivie-tipi/) int (vai vesels skaitlis), atlikums var tikt viegli izteikts bez Java modulo. Kods izskatītos šādi:

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

Tad varam izmantot Java komandu `System.out.println`, lai apskatītu rezultātu:

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

Šī opcija ir nedaudz nepraktiska, bet teorētiski iespējama. Tomēr problēmas radīsies, tiklīdz vismaz viens no operandiem būs float vai double, tas ir, peldošā komata datu tips. Šajā gadījumā tas pats aprēķins dos mums atšķirīgu rezultātu:

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

## Kāda ir modulo sintakse Java valodā?

Java modulo operators, no otras puses, vienmēr atgriež **precīzu atlikumu**. Tas veic dalīšanu, bet parāda tikai atlikumu, nevis dalījuma rezultātu. Tas tiek inicializēts ar procentu zīmi, kas nozīmē, ka tā sintakse izskatās šādi:

```java
Dividend % Divisor
```

Java modulo izskatītos šādi, ja to izmantotu iepriekš minētajā piemērā:

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

Rezultāts ir šāds:

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

## Kā noteikt, vai skaitlis ir pāra vai nepāra

Java modulo var izmantot, lai noskaidrotu, vai skaitlis ir pāra vai nepāra. Tas izriet no vienkāršas loģikas: ja jebkuru skaitli dala ar 2 un atlikums ir 0, tas ir pāra skaitlis. Pretējā gadījumā tas ir nepāra skaitlis. To ilustrēsim ar **if-else izteikumu**.

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

Kā gaidīts, mēs iegūstam šādu rezultātu:

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

## Kā noteikt negatīva skaitļa atlikumu

Jūs varat izmantot arī Java modulo, lai iegūtu atlikumu, ja dalāmais vai dalītājs ir negatīvs. Šeit ir vienkāršs piemērs:

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

Tā kā dividende ir negatīva, arī atlikums ir negatīvs:

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

Bet varbūt jūs ne vienmēr vēlaties iegūt negatīvu rezultātu. Ja vēlaties **iegūt pozitīvu atlikumu**, varat nedaudz modificēt kodu. Vispirms pārbaudiet, vai atlikums ir mazāks par 0. Ja tā ir, pievienojiet dalītāju, un iegūsiet pozitīvu atlikumu. Šāds būs koda izskats:

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

Mēs iegūsim šādu rezultātu:

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


This is a markdown version of: [https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-modulo/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-modulo/) for AI/LLM consumption.