# Kako uporabljati Java modulo operator

Ko deljenje ne deluje popolnoma, ostane ostanek. Java modulo operator je namenjen upoštevanju tega v vašem kodu. Operator je bistveno zanesljivejši od drugih rešitev in se uporablja predvsem za ugotavljanje, ali so števila siva ali liha.

## Kaj je Java modulo operator?

V vseh pogostih programskih jezikih lahko izvajate osnovne aritmetične operacije seštevanja, odštevanja, množenja in deljenja. Za prikazovanje in reševanje zapletenih izračunov lahko uporabite tudi Java operacije. Pri deljenju obstaja vedno tveganje, da **bo ostalo ostanek**. Če na primer delite 11 z 4, boste dobili ostanek 3 (*2 x 4 = 8, 11 - 8 = 3*). To lahko povzroči težave pri programiranju.

Za to je namenjen Java modulo operator. Poznan je tudi kot operator za ostanek, saj določi in vrne **ostanek po delitvi dveh številk**. Obstajajo različne situacije, v katerih je izredno pomemben. Operator se lahko uporabi na primer za ugotavljanje, ali je število sodo ali liho ali pa je število praštevilo. Čeprav obstajajo tudi drugi načini za določanje ostanka, ti hitro dosežejo svoje meje. To bo ponazoril naslednji primer.

## Za kaj se uporablja operator za ostanek?

Preprosto povedano, deljenje vključuje preverjanje, kolikokrat se delitelj prilega v deljenec. Rezultat je količnik. Če sta deljenec in delitelj shranjena v [primitivnem podatkovnem tipu Java](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-primitivni-tipi/) int (ali celo število), se ostanek lahko enostavno izrazi brez Java modulo. Koda bi bila naslednja:

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

Rezultat lahko nato ogledamo z ukazom Java `System.out.println`:

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

Ta možnost je nekoliko okorna, vendar je v teoriji izvedljiva. Vendar pa bomo naleteli na težave, če je vsaj eden od operandov float ali double, torej tip podatkov s plavajočo vejico. V tem primeru bo isti izračun dal drugačen 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
```

## Kakšna je sintaksa modula v Javi?

Java modulo operator pa vedno vrne **natančen ostanek**. Izvede deljenje, vendar prikaže le ostanek, ne pa tudi kvocient. Inicializira se z znakom odstotka, kar pomeni, da je njegova sintaksa naslednja:

```java
Dividend % Divisor
```

Java modulo bi v zgornjem primeru izgledal takole:

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

Rezultat je nato:

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

## Kako ugotoviti, ali je število liho ali sodo

Java modulo se lahko uporabi za ugotavljanje, ali je število sodo ali liho. Izhaja iz preproste logike: če katero koli število delite z 2 in je ostanek 0, je sodo. V nasprotnem primeru je liho. To bomo ponazorili z **izjavo if-else**.

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

Kot pričakovano, dobimo naslednji rezultat:

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

## Kako določiti ostanek negativnega števila

Java modulo lahko uporabite tudi za izračun ostanka, kadar je deljenec ali delitelj negativen. Tukaj je preprost primer:

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

Ker je dividenda negativna, je tudi preostanek negativen:

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

Vendar pa morda ne želite vedno dobiti negativnega rezultata. Če želite **vrniti pozitivni ostanek**, lahko kodo nekoliko spremenite. Najprej preverite, ali je ostanek manjši od 0. Če je, dodajte delitelja in dobili boste pozitivni ostanek. Tako bo izgledala koda:

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

Dobili bomo naslednji izpis:

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


This is a markdown version of: [https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-modulo/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/java-modulo/) for AI/LLM consumption.