Java Modulo : fonc­tion­ne­ment 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é­so­lu­tion et permet surtout de dé­ter­mi­ner si les nombres sont pairs ou impairs.

L’opérateur modulo en langage Java

Tous les langages de pro­gram­ma­tion courants per­met­tent d’effectuer les quatre opé­ra­tions arith­mé­tiques de base que sont l’addition, la sous­trac­tion, la mul­ti­pli­ca­tion et la division, et de re­pré­sen­ter et de résoudre des tâches arith­mé­tiques complexes, notamment à l’aide des opé­ra­teurs Java ap­pro­prié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 pro­gram­ma­tion, 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 pro­gram­ma­tion.

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 pro­gram­ma­tion, son uti­li­sa­tion peut s’avérer es­sen­tielle dans certaines si­tua­tions. Il peut, par exemple, dé­ter­mi­ner 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 cir­cons­tances, ils at­teig­nent vite leurs limites. L’exemple ci-après en est l’il­lus­tra­tion.

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

Lors de la division, on vérifie, pour sim­pli­fier, 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 pri­mi­tives Java int (Integer) vous pouvez calculer la valeur restante sans problème, sans l’opérateur modulo. Le code cor­res­pon­dant peut res­sem­bler à ceci :

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’in­di­ca­tion suivante :

La valeur restante est : 3

C’est un peu compliqué, mais en principe possible. Cela devient toutefois pro­blé­ma­tique 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 :

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

La valeur restante est : 0,0

Syntaxe et fonc­tion­ne­ment 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 pour­cen­tage et sa syntaxe simple se présente comme suit :

Dividende % Diviseur

Dans notre exemple précédent, l’opérateur fonc­tion­ne­rait donc ainsi :

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’in­di­ca­tion générée est :

La valeur restante est : 3.0

Dé­ter­mi­ner 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 rai­son­ne­ment simple : si l’on divise un dividende quel­conque par 2 et que la valeur restante est 0, le nombre est pair. Si non, le nombre doit être impair. Une ins­truc­tion con­di­tion­nelle if else permet d’illustrer cette hypothèse. Voici le code cor­res­pon­dant :

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’in­di­ca­tion suivante :

11 est un nombre impair.

Valeur restante avec des chiffres négatifs

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

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’in­di­ca­tion obtenue est donc :

La valeur restante est : -3

Cependant, obtenir un résultat négatif n’est pas toujours le but recherché. En adaptant lé­gè­re­ment 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 in­fé­rieure à 0. Si c’est le cas, il suffit d’y ad­di­tion­ner le diviseur pour obtenir une valeur restante positive. Le code prend alors la forme suivante :

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’in­di­ca­tion suivante :

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