Division entière en Java

En Java, la division de deux valeurs entières renvoie un quotient entier tronqué vers zéro. Avec deux opérandes de type int, 10 / 9 vaut 1, tandis que 10 / 19 vaut 0 : Java n’arrondit pas le quotient. Utilisez % pour obtenir le reste, ou convertissez un opérande en double avant la division si vous avez besoin d’un résultat décimal.

Principes de la division entière

Ce programme Java complet affiche le quotient obtenu pour quatre paires de valeurs int :

public class IntegerDivision {
    public static void main(String[] args) {
        int first = 10 / 9;
        int second = -10 / 9;
        int third = 10 / -9;
        int fourth = 10 / 19;

        System.out.println(first);
        System.out.println(second);
        System.out.println(third);
        System.out.println(fourth);
    }
}

1
-1
-1
0

Lorsque les deux opérandes sont non nuls, le quotient est négatif si un seul d’entre eux est négatif. Un quotient positif inférieur à 1, comme 10 / 19, devient 0. -10 / 19 devient également 0, car la troncature se fait vers zéro. Si le numérateur vaut zéro, le quotient vaut 0 quel que soit le diviseur non nul.

Obtenir le reste avec l’opérateur modulo

L’opérateur % renvoie le reste de la division entière. Utilisez / et % ensemble lorsque votre calcul a besoin du quotient et du reste. Pour des opérandes entiers signés en Java, le reste porte le signe du dividende (l’opérande de gauche), ou vaut zéro :

public class QuotientAndRemainder {
    public static void main(String[] args) {
        int dividend = -10;
        int divisor = 3;
        int quotient = dividend / divisor;
        int remainder = dividend % divisor;

        System.out.println("Quotient: " + quotient);
        System.out.println("Remainder: " + remainder);
    }
}

Quotient: -3
Remainder: -1

Les valeurs vérifient dividend == quotient * divisor + remainder : ici, -10 == (-3 * 3) + (-1). Cette propriété est utile pour vérifier, par exemple, si number % 2 == 0 afin de déterminer si un entier est pair. En Java, % est souvent appelé l’opérateur modulo ; avec des valeurs négatives, gardez toutefois à l’esprit que le reste conserve le signe du dividende.

Convertir un opérande pour obtenir un résultat précis

Pour obtenir un quotient décimal, convertissez au moins un opérande en float ou en double avant l’évaluation de /. La conversion fait alors de l’opération une division en virgule flottante :

public class FloatingPointDivision {
    public static void main(String[] args) {
        int numerator = 5;
        int denominator = 2;
        double result = (double) numerator / denominator;

        System.out.println(result);
    }
}

2.5

La conversion a lieu avant la division : 5 est donc traité comme un double et la partie fractionnaire du quotient est conservée. En revanche, (double) (5 / 2) convertit seulement le résultat entier déjà calculé, 2, en 2.0 ; la fraction perdue ne peut pas être retrouvée. Les types float et double ont une précision binaire finie : de nombreuses fractions décimales ne sont donc représentées qu’approximativement. Pour un calcul général, double convient habituellement. Ne vous attendez pas à un nombre fixe de chiffres décimaux affichés. Pour une arithmétique décimale exacte, par exemple sur des montants, utilisez BigDecimal avec une échelle et une règle d’arrondi explicites.

Pièges courants de la division entière

Un diviseur entier égal à zéro provoque une ArithmeticException. Vérifiez le diviseur avant la division, ou interceptez l’exception si une vérification préalable n’est pas pratique. Par exemple :

public class SafeDivision {
    public static void main(String[] args) {
        int numerator = 10;
        int denominator = 0;

        if (denominator == 0) {
            System.out.println("Cannot divide by zero.");
        } else {
            System.out.println(numerator / denominator);
        }
    }
}

Cannot divide by zero.

Cette vérification est utile lorsque denominator provient d’une saisie ou d’un calcul. Une division entière par zéro déclenche l’exception avant que l’affectation puisse aboutir. La division en virgule flottante suit d’autres règles : une division de type double ou float par zéro produit une valeur infinie ou NaN, et non cette ArithmeticException. Vérifiez ces résultats s’ils n’ont pas de sens pour votre application.

Une autre limite des entiers peut surprendre : Integer.MIN_VALUE / -1 dépasse la plage de int et donne Integer.MIN_VALUE. Java ne déclenche pas d’exception dans ce cas de dépassement. Si vos valeurs peuvent être proches des limites du type, choisissez un type plus large ou vérifiez la plage avant de vous fier au quotient.

Conclusion

En Java, / tronque le quotient vers zéro pour une division entière ; % fournit le reste signé. Convertissez un opérande avant la division pour obtenir un quotient en virgule flottante et vérifiez que tout diviseur entier est différent de zéro.

FAQ

Que se passe-t-il lorsqu’on divise un int par zéro ?
Java déclenche une ArithmeticException. Vérifiez d’abord le diviseur ou interceptez l’exception.

Comment obtenir un résultat décimal ?
Convertissez au moins un opérande en double ou en float avant d’utiliser /.

Comment obtenir le reste ?
Utilisez %, par exemple : int remainder = dividend % divisor;.

Peut-on utiliser la division entière dans une boucle ?
Oui. N’oubliez pas que chaque division entière tronque vers zéro ; utilisez un opérande en virgule flottante si le calcul de la boucle doit conserver des fractions.