# Java Modulo : fonctionnement et utilité de l’opérateur de valeur restante

Si une division n’est pas exacte, il reste une valeur restante. Pour bien calculer cette valeur dans votre programme, Java propose l’opérateur `modulo`. Ce dernier est nettement plus fiable que les autres méthodes de résolution et permet surtout de déterminer si les nombres sont pairs ou impairs.

## L’opérateur `modulo` en langage Java

Tous les langages de programmation courants permettent d’effectuer les quatre opérations arithmétiques de base que sont l’addition, la soustraction, la multiplication et la division, et de représenter et de résoudre des tâches arithmétiques complexes, notamment à l’aide des opérateurs Java appropriés. Dans le cas de la division, le risque de **ne pas obtenir un résultat exact** existe bien sûr dans le domaine de la programmation, mais pas seulement. Lorsque deux entiers sont divisés, une valeur restante est toujours possible. Par exemple, en divisant 11 par 4, il reste une valeur restante de 3 (*2 x 4 = 8, 11 - 8 = 3*), ce qui peut poser des problèmes lors de la programmation.

Il existe donc en langage Java un outil, l’opérateur `modulo`, qui détermine et affiche le **reste après une division de deux nombres**. Celui-ci est également appelé « opérateur de reste ». En programmation, son utilisation peut s’avérer essentielle dans certaines situations. Il peut, par exemple, déterminer si un nombre attendu est pair ou impair, ou s’il s’agit d’un nombre premier. Il y a certes d’autres moyens de calculer la valeur restante, mais dans certaines circonstances, ils atteignent vite leurs limites. L’exemple ci-après en est l’illustration.

## À quoi sert l’opérateur de valeur restante ?

Lors de la division, on vérifie, pour simplifier, combien de fois un diviseur entre dans un dividende. Le résultat s’appelle le quotient. Si le dividende et le diviseur sont tous deux stockés dans le [type de données primitives Java](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-primitives/) `int` (Integer) vous pouvez calculer la valeur restante sans problème, sans l’opérateur `modulo`. Le code correspondant peut ressembler à ceci :

```java
public class Main {
	public static void main(String[] args) {
	int dividende = 11;
	int diviseur = 4;
	int valeur_restante = dividende - (diviseur * (dividende / diviseur));
	System.out.println(" La valeur restante est : " + valeur_restante);
	}
}
```

En utilisant la commande Java `System.out.println` vous obtenez l’indication suivante :

```java
La valeur restante est : 3
```

C’est un peu compliqué, mais en principe possible. Cela devient toutefois problématique dès qu’au moins un des opérandes est de type `float` ou `double`, à savoir un type de données à virgule flottante. Dans ce cas, pour le même calcul, le résultat obtenu est différent :

```java
public class Main {
	public static void main(String[] args) {
	int dividende = 11;
	double diviseur = 4;
	double valeur_restante = dividende - (diviseur * (dividende / diviseur));
	System.out.println("La valeur restante est : " + valeur_restante);
	}
}
```

```java
La valeur restante est : 0,0
```

## Syntaxe et fonctionnement de l’opérateur Java `modulo`

En revanche, l’opérateur `modulo` en langage Java affiche toujours la **valeur restante exacte**. Il effectue bien la division, mais n’affiche pas le résultat, seulement le reste à la fin. Il est initié par un signe de pourcentage et sa syntaxe simple se présente comme suit :

```java
Dividende % Diviseur
```

Dans notre exemple précédent, l’opérateur fonctionnerait donc ainsi :

```java
public class Main {
	public static void main(String[] args) {
	int dividende = 11;
	double diviseur = 4;
	double valeur_restante = dividende % diviseur;
	System.out.println("La valeur restante est : " + valeur_restante);
	}
}
```

L’indication générée est :

```java
La valeur restante est : 3.0
```

## Déterminer si les nombres sont pairs ou impairs

L’opérateur `modulo` en langage Java vous permet de savoir si un nombre est pair ou impair. Pour cela, on a recours à un raisonnement simple : si l’on divise un dividende quelconque par 2 et que la valeur restante est 0, le nombre est pair. Si non, le nombre doit être impair. Une instruction conditionnelle ***if else*** permet d’illustrer cette hypothèse. Voici le code correspondant :

```java
public class Main {
	public static void main(String[] args) {
		int dividende = 11;
		if (dividende % 2 == 0) {
		System.out.println(dividende + " est un nombre pair.");
		}
		else {
		System.out.println(dividende + " est un nombre impair.");
		}
}
```

Comme on pouvait s’y attendre, nous obtenons l’indication suivante :

```java
11 est un nombre impair.
```

## Valeur restante avec des chiffres négatifs

Selon ce principe, il est tout à fait possible de déterminer la valeur restante lorsque le dividende ou le diviseur sont négatifs. En voici un exemple simple :

```java
public class Main {
	public static void main(String[] args) {
	int dividende = -11;
	int diviseur = 4;
	int valeur_restante = dividende % diviseur;
	System.out.println("La valeur restante est : " + valeur_restante);
	}
}
```

Puisque le dividende est négatif, la valeur restante sera toujours négative. L’indication obtenue est donc :

```java
La valeur restante est : -3
```

Cependant, obtenir un résultat négatif n’est pas toujours le but recherché. En adaptant légèrement le code, il est possible d’obtenir une **valeur restante positive**. Pour ce faire, il faut d’abord vérifier si la valeur restante est inférieure à 0. Si c’est le cas, il suffit d’y additionner le diviseur pour obtenir une valeur restante positive. Le code prend alors la forme suivante :

```java
public class Main {
	public static void main(String[] args) {
	int dividende = -11;
	int diviseur = 4;
	int valeur_restante = dividende % diviseur;
	System.out.println("La valeur restante avant modification est : " + valeur_restante);
	while (dividende < 0) dividende += diviseur;
	int valeur_restante_positive = dividende % diviseur;
	System.out.println("La valeur restante après modification est : " + valeur_restante_positive);
	}
}
```

Désormais, nous obtenons l’indication suivante :

```java
La valeur restante avant modification est : -3
La valeur restante après modification est : 1
```


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/loperateur-java-modulo/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/loperateur-java-modulo/) for AI/LLM consumption.