# Kaip naudoti Java modulo operatorius

Kai dalybos rezultatas nėra lygus nuliui, lieka likutis. Java modulo operatorius skirtas tai atsižvelgti jūsų kode. Šis operatorius yra žymiai patikimesnis nei kiti sprendimai ir dažniausiai naudojamas norint nustatyti, ar skaičiai yra lyginiai ar nelyginiai.

## Kas yra Java modulo operatorius?

Visose populiariose programavimo kalbose galima atlikti pagrindines aritmetines operacijas: sudėties, atimties, daugybos ir dalybos. Taip pat galite naudoti Java operatorius, kad būtų rodomi ir sprendžiami sudėtingi skaičiavimai. Kalbant apie dalybą, visada yra rizika, kad **liks likutis**. Pavyzdžiui, jei 11 padalinsite iš 4, likutis bus 3 (*2 x 4 = 8, 11 - 8 = 3*). Tai gali sukelti problemų programavimo metu.

Būtent tam ir skirtas Java modulo operatorius. Jis taip pat žinomas kaip likučio operatorius, nes jis nustato ir grąžina **likutį po dviejų skaičių dalybos**. Yra įvairių situacijų, kuriose tai yra ypač svarbu. Operatorius gali būti naudojamas, pavyzdžiui, norint sužinoti, ar skaičius yra lyginis ar nelyginis, ar skaičius yra pirminis. Nors yra ir kitų būdų likučiui nustatyti, jie greitai pasiekia savo ribas. Tai iliustruoja toliau pateiktas pavyzdys.

## Kam naudojamas likučio operatorius?

Paprastai tariant, dalybos metu tikrinama, kiek kartų daliklis telpa į dalinamąjį. Rezultatas yra dalmuo. Jei dalinamasis ir daliklis yra saugomi [primityviame Java duomenų tipe](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/java-primityvai/) int (arba sveikasis skaičius), likutis gali būti lengvai išreikštas be Java modulo. Kodas atrodytų taip:

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

Tada galime naudoti Java komandą `System.out.println`, kad peržiūrėtume rezultatą:

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

Ši galimybė yra šiek tiek sudėtinga, bet teoriškai įmanoma. Tačiau problemos kils, kai bent vienas iš operandų bus float arba double, t. y. plaukiojančiojo kablelio duomenų tipas. Šiuo atveju tas pats skaičiavimas duos kitokį rezultatą:

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

## Kokia yra modulo sintaksė Java kalboje?

Kita vertus, Java modulo operatorius visada grąžina **tikslų likutį**. Jis atlieka dalybą, bet rodo tik likutį, o ne dalmenį. Jis inicijuojamas procentų ženklu, todėl jo sintaksė atrodo taip:

```java
Dividend % Divisor
```

Java modulo atrodytų taip, kaip naudojamas aukščiau pateiktame pavyzdyje:

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

Tada rezultatas yra toks:

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

## Kaip nustatyti, ar skaičius yra nelyginis ar lyginis

Java modulo gali būti naudojamas norint išsiaiškinti, ar skaičius yra lyginis, ar nelyginis. Tai išplaukia iš paprastos logikos: jei bet kokį skaičių padalinsite iš 2 ir likutis bus 0, tai skaičius yra lyginis. Kitaip jis yra nelyginis. Tai iliustruosime **if-else teiginiu**.

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

Kaip ir tikėtasi, gauname tokį rezultatą:

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

## Kaip nustatyti neigiamo skaičiaus likutį

Java modulo taip pat galima naudoti norint gauti likutį, kai dalinamas skaičius arba daliklis yra neigiamas. Štai paprastas pavyzdys:

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

Kadangi dividendai yra neigiami, likutis taip pat yra neigiamas:

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

Tačiau ne visada norėsite gauti neigiamą rezultatą. Jei norite **grąžinti teigiamą likutį**, galite šiek tiek pakeisti kodą. Pirmiausia patikrinkite, ar likutis yra mažesnis už 0. Jei taip, pridėkite daliklį ir gausite teigiamą likutį. Štai kaip atrodys šis kodas:

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

Gausime tokį rezultatą:

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


This is a markdown version of: [https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/java-modulis/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/java-modulis/) for AI/LLM consumption.