¿Cómo puedo comprobar si multiplicar dos números en Java provocará un desbordamiento?

Quiero manejar el caso especial en el que la multiplicación de dos números provoca un desbordamiento. El código se parece a esto:

int a = 20;
long b = 30;

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

Esa es una versión simplificada. En el programa real ay bse obtienen en otro lugar en tiempo de ejecución. Lo que quiero lograr es algo como esto:

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

¿Cómo sugieres que codifique mejor esto?

Actualización: ay bsiempre son no negativos en mi escenario.

Java 8 tiene Math.multiplyExact, Math.addExactetc. para ints y long. Éstos arrojan un ArithmeticExceptiondesbordamiento sin control .

Si ay bambos son positivos, puede usar:

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

Si necesita lidiar con números positivos y negativos, entonces es más complicado:

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
}

Aquí hay una pequeña mesa que preparé para verificar esto, fingiendo que el desbordamiento ocurre en -10 o +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

Hay bibliotecas de Java que proporcionan operaciones aritméticas seguras, que verifican el desbordamiento / subdesbordamiento largos. Por ejemplo, LongMath.checkedMultiply de Guava (long a, long b) devuelve el producto de ay b, siempre que no se desborde, y arroja ArithmeticExceptionsi se a * bdesborda en longaritmética con signo .

En su lugar, podría usar java.math.BigInteger y verificar el tamaño del resultado (no he probado el código):

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

Utilice logaritmos para comprobar el tamaño del resultado.

¿Java tiene algo como int.MaxValue? Si es así, intente

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

editar: visto Long.MAX_VALUE en cuestión

Esta es la forma más sencilla que se me ocurre

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"
}

Robado de jruby

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

ACTUALIZACIÓN: este código es corto y funciona bien; sin embargo, falla para a = -1, b = Long.MIN_VALUE.

Una posible mejora:

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

Tenga en cuenta que esto detectará algunos desbordamientos sin ninguna división.

Como se ha señalado, Java 8 tiene métodos Math.xxxExact que arrojan excepciones al desbordamiento.

Si no está utilizando Java 8 para su proyecto, aún puede "tomar prestadas" sus implementaciones, que son bastante compactas.

Aquí hay algunos enlaces a estas implementaciones en el repositorio de código fuente de JDK, no hay garantía de que sigan siendo válidas, pero en cualquier caso, debería poder descargar la fuente de JDK y ver cómo hacen su magia dentro de la java.lang.Mathclase.

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étera etcétera.

ACTUALIZADO: se cambiaron los enlaces no válidos a sitios web de terceros por enlaces a los repositorios Mercurial de Open JDK.

No estoy seguro de por qué nadie está buscando una solución como:

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

Elija a para que sea mayor de los dos números.

Me gustaría aprovechar la respuesta de John Kugelman sin reemplazarla editándola directamente. Funciona para su caso de prueba ( MIN_VALUE = -10, MAX_VALUE = 10) debido a la simetría de MIN_VALUE == -MAX_VALUE, que no es el caso de los enteros en complemento a dos. En la actualidad, 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)

Cuando se aplica al verdadero MIN_VALUEy MAX_VALUE, la respuesta de John Kugelman produce un caso de desbordamiento cuando a == -1y b ==cualquier otra cosa (punto planteado por primera vez por Kyle). He aquí una forma de solucionarlo:

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
}

No es una solución general para cualquier MIN_VALUEe MAX_VALUE, pero es general para Java Longy Integery cualquier valor de ay b.

Tal vez:

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

No estoy seguro de esta "solución".

Editar: Se agregó b! = 0.

Antes de votar en contra : a * b / b no se optimizará. Este sería un error del compilador. Todavía no veo un caso en el que se pueda enmascarar el error de desbordamiento.

tal vez esto te ayude:

/**
 * @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 ++ (largo * largo):

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

java (int * int, lo siento, no encontré int64 en 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.Guarde el resultado en tipo grande (int * int pone el resultado en long, long * long puesto en int64)

2.cmp resultado >> bits y resultado >> (bits - 1)