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 int (Integer) vous pouvez calculer la valeur restante sans problème, sans l’opérateur modulo. Le code correspondant peut ressembler à 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’indication suivante :

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 :

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

Dividende % Diviseur

Dans notre exemple précédent, l’opérateur fonctionnerait 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’indication générée est :

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 :

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 :

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 :

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 :

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 :

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 :

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