Comment puis-je vérifier si la multiplication de deux nombres en Java provoquera un dépassement de capacité ?

Question

Je veux gérer le cas particulier où la multiplication de deux nombres provoque un débordement. Le code ressemble à quelque chose comme 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 vrai programme a y b proviennent d'autres sources 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;
}

Quelle est la meilleure façon de coder cela ?

Mise à jour : a y b sont toujours non négatives dans mon scénario.

Answer 1

Si a y b sont toutes deux positives, alors vous pouvez utiliser :

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

Si vous devez traiter 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 préparé pour vérifier cela, en prétendant que le dépassement 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

Answer 2

Il existe des bibliothèques Java qui fournissent des opérations arithmétiques sûres, qui vérifient les débordements et les sous-exécutions de longue durée. Par exemple, la bibliothèque Guava LongMath.checkedMultiply(long a, long b) renvoie le produit de a y b à condition qu'il ne déborde pas, et lance ArithmeticException si a * b les débordements dans les produits signés long arithmétique.

Answer 3

Vous pourriez 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()
}

Answer 4

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

Answer 5

Est-ce que Java a 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