Comment puis-je vérifier si la multiplication de deux nombres en Java entraînera un débordement?

Je veux gérer le cas particulier où la multiplication de deux nombres ensemble provoque un débordement. Le code ressemble à ceci:

int a = 20;
long b = 30;

// if a or b are big enough, this result will silently overflow
long c = a * b;

C'est une version simplifiée. Dans le programme réel aet bproviennent ailleurs au moment de l'exécution. Ce que je veux réaliser est quelque chose comme ceci:

long c;
if (a * b will overflow) {
    c = Long.MAX_VALUE;
} else {
    c = a * b;
}

Comment me suggérez-vous de coder au mieux cela?

Mise à jour: aet bsont toujours non négatifs dans mon scénario.

Java 8 a Math.multiplyExact, Math.addExactetc. pour les entiers et les longs. Ceux-ci lancent un ArithmeticExceptiondébordement non contrôlé .

Si aet bsont tous les deux positifs, vous pouvez utiliser:

if (a != 0 && b > Long.MAX_VALUE / a) {
    // Overflow
}

Si vous devez gérer à la fois des nombres positifs et négatifs, c'est plus compliqué:

long maximum = Long.signum(a) == Long.signum(b) ? Long.MAX_VALUE : Long.MIN_VALUE;

if (a != 0 && (b > 0 && b > maximum / a ||
               b < 0 && b < maximum / a))
{
    // Overflow
}

Voici un petit tableau que j'ai créé pour vérifier cela, en prétendant que le débordement se produit à -10 ou +10:

a =  5   b =  2     2 >  10 /  5
a =  2   b =  5     5 >  10 /  2
a = -5   b =  2     2 > -10 / -5
a = -2   b =  5     5 > -10 / -2
a =  5   b = -2    -2 < -10 /  5
a =  2   b = -5    -5 < -10 /  2
a = -5   b = -2    -2 <  10 / -5
a = -2   b = -5    -5 <  10 / -2

Il existe des bibliothèques Java qui fournissent des opérations arithmétiques sûres, qui vérifient les longs débordements / sous-débordements. Par exemple, LongMath.checkedMultiply de Guava (long a, long b) renvoie le produit de aet b, à condition qu'il ne déborde pas, et renvoie ArithmeticExceptionsi a * bdéborde en longarithmétique signée .

Vous pouvez utiliser java.math.BigInteger à la place et vérifier la taille du résultat (je n'ai pas testé le code):

BigInteger bigC = BigInteger.valueOf(a) * multiply(BigInteger.valueOf(b));
if(bigC.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0) {
  c = Long.MAX_VALUE;
} else {
  c = bigC.longValue()
}

Utilisez des logarithmes pour vérifier la taille du résultat.

Java a-t-il quelque chose comme int.MaxValue? Si oui, essayez

if (b != 0 && Math.abs(a) > Math.abs(Long.MAX_VALUE / b))
{
 // it will overflow
}

edit: vu Long.MAX_VALUE en question

Voici le moyen le plus simple auquel je puisse penser

int a = 20;
long b = 30;
long c = a * b;

if(c / b == a) {
   // Everything fine.....no overflow
} else {
   // Overflow case, because in case of overflow "c/b" can't equal "a"
}

Volé à jruby

    long result = a * b;
    if (a != 0 && result / a != b) {
       // overflow
    }

MISE À JOUR: Ce code est court et fonctionne bien; cependant, il échoue pour a = -1, b = Long.MIN_VALUE.

Une amélioration possible:

long result = a * b;
if( (Math.signum(a) * Math.signum(b) != Math.signum(result)) || 
    (a != 0L && result / a != b)) {
    // overflow
}

Notez que cela rattrapera certains débordements sans aucune division.

Comme cela a été souligné, Java 8 a des méthodes Math.xxxExact qui lèvent des exceptions en cas de débordement.

Si vous n'utilisez pas Java 8 pour votre projet, vous pouvez toujours «emprunter» leurs implémentations qui sont assez compactes.

Voici quelques liens vers ces implémentations dans le référentiel de code source JDK, aucune garantie que ceux-ci resteront valides, mais dans tous les cas, vous devriez pouvoir télécharger la source JDK et voir comment ils font leur magie à l'intérieur de la java.lang.Mathclasse.

Math.multiplyExact(long, long) http://hg.openjdk.java.net/jdk/jdk11/file/1ddf9a99e4ad/src/java.base/share/classes/java/lang/Math.java#l925

Math.addExact(long, long) http://hg.openjdk.java.net/jdk/jdk11/file/1ddf9a99e4ad/src/java.base/share/classes/java/lang/Math.java#l830

etc.

MISE À JOUR: les liens invalides vers le site Web tiers ont été remplacés par des liens vers les référentiels Mercurial d'Open JDK.

Je ne sais pas pourquoi personne ne cherche une solution comme:

if (Long.MAX_VALUE/a > b) {
     // overflows
} 

Choisissez a pour être le plus grand des deux nombres.

J'aimerais m'appuyer sur la réponse de John Kugelman sans la remplacer en la modifiant directement. Cela fonctionne pour son cas de test ( MIN_VALUE = -10, MAX_VALUE = 10) en raison de la symétrie de MIN_VALUE == -MAX_VALUE, ce qui n'est pas le cas pour les entiers complémentaires à deux. En réalité, MIN_VALUE == -MAX_VALUE - 1.

scala> (java.lang.Integer.MIN_VALUE, java.lang.Integer.MAX_VALUE)
res0: (Int, Int) = (-2147483648,2147483647)

scala> (java.lang.Long.MIN_VALUE, java.lang.Long.MAX_VALUE)
res1: (Long, Long) = (-9223372036854775808,9223372036854775807)

Lorsqu'elle est appliquée au vrai MIN_VALUEet MAX_VALUE, la réponse de John Kugelman produit un cas de débordement quand a == -1et b ==quoi que ce soit d'autre (point soulevé en premier par Kyle). Voici un moyen de résoudre ce problème:

long maximum = Long.signum(a) == Long.signum(b) ? Long.MAX_VALUE : Long.MIN_VALUE;

if ((a == -1 && b == Long.MIN_VALUE) ||
    (a != -1 && a != 0 && ((b > 0 && b > maximum / a) ||
                           (b < 0 && b < maximum / a))))
{
    // Overflow
}

Ce n'est pas une solution générale pour tout MIN_VALUEet MAX_VALUE, mais elle est générale pour Java Longet Integeret toute valeur de aet b.

Peut être:

if(b!= 0 && a * b / b != a) //overflow

Pas sûr de cette "solution".

Edit: Ajouté b! = 0.

Avant de voter contre : a * b / b ne sera pas optimisé. Ce serait un bogue du compilateur. Je ne vois toujours pas de cas où le bug de débordement peut être masqué.

peut-être que cela vous aidera:

/**
 * @throws ArithmeticException on integer overflow
 */
static long multiply(long a, long b) {
    double c = (double) a * b;
    long d = a * b;

    if ((long) c != d) {
        throw new ArithmeticException("int overflow");
    } else {
        return d;
    }
}

c / c ++ (long * long):

const int64_ w = (int64_) a * (int64_) b;    
if ((long) (w >> sizeof(long) * 8) != (long) w >> (sizeof(long) * 8 - 1))
    // overflow

java (int * int, désolé je n'ai pas trouvé int64 dans java):

const long w = (long) a * (long) b;    
int bits = 32; // int is 32bits in java    
if ( (int) (w >> bits) ！= (int) (w >> (bits - 1))) {
   // overflow
}

1. enregistrez le résultat en grand type (int * int met le résultat à long, long * long mis à int64)

2.cmp résultat >> bits et résultat >> (bits - 1)