Como posso verificar se a multiplicação de dois números em Java causará um estouro?

Quero lidar com o caso especial em que a multiplicação de dois números causa um estouro. O código é parecido com este:

int a = 20;
long b = 30;

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

Essa é uma versão simplificada. No programa real ae bsão obtidos em outro lugar em tempo de execução. O que eu quero alcançar é algo assim:

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

Como você sugere que eu codifique melhor isso?

Update: ae bsão sempre não negativos no meu cenário.

Java 8 tem Math.multiplyExact, Math.addExactetc. para ints e long. Estes lançam um ArithmeticExceptionestouro desmarcado .

Se ae bforem positivos, você pode usar:

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

Se você precisa lidar com números positivos e negativos, é mais 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
}

Aqui está uma pequena mesa que criei para verificar isso, fingindo que o estouro acontece em -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

Existem bibliotecas Java que fornecem operações aritméticas seguras, que verificam longo estouro / estouro negativo. Por exemplo, LongMath.checkedMultiply (long a, long b) do Guava retorna o produto de ae b, desde que não estourou, e lança ArithmeticExceptionse a * bestourou na longaritmética assinada .

Você pode usar java.math.BigInteger em vez disso e verificar o tamanho do resultado (não testei o 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()
}

Use logaritmos para verificar o tamanho do resultado.

Java tem algo como int.MaxValue? Se sim, então tente

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

editar: visto Long.MAX_VALUE em questão

Aqui está a maneira mais simples que posso pensar

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

Roubado de jruby

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

ATUALIZAÇÃO: Este código é curto e funciona bem; no entanto, ele falha para a = -1, b = Long.MIN_VALUE.

Um possível aprimoramento:

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

Observe que isso irá capturar alguns overflows sem qualquer divisão.

Como foi apontado, o Java 8 possui métodos Math.xxxExact que lançam exceções no estouro.

Se você não estiver usando Java 8 para o seu projeto, ainda pode "pegar emprestado" suas implementações, que são bastante compactas.

Aqui estão alguns links para essas implementações no repositório de código-fonte JDK, nenhuma garantia se eles permanecerão válidos, mas em qualquer caso, você deve ser capaz de baixar o código-fonte JDK e ver como eles fazem sua mágica dentro da 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 etc.

ATUALIZADO: foram removidos links inválidos para sites de terceiros para links para os repositórios Mercurial do Open JDK.

Não sei por que ninguém está olhando para uma solução como:

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

Escolha a para ser o maior dos dois números.

Eu gostaria de desenvolver a resposta de John Kugelman sem substituí-la editando-a diretamente. Isso funciona para seu caso de teste ( MIN_VALUE = -10, MAX_VALUE = 10) por causa da simetria de MIN_VALUE == -MAX_VALUE, que não é o caso para inteiros de complemento de dois. Na realidade 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)

Quando aplicada ao verdadeiro MIN_VALUEe MAX_VALUE, a resposta de John Kugelman produz um caso de estouro quando a == -1e b ==qualquer outra coisa (ponto levantado pela primeira vez por Kyle). Esta é uma maneira de consertar:

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
}

Não é uma solução geral para qualquer MIN_VALUEe MAX_VALUE, mas é geral para Java de Longe Integere qualquer valor de ae b.

Talvez:

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

Não tenho certeza sobre esta "solução".

Editar: Adicionado b! = 0.

Antes de fazer downvote : a * b / b não será otimizado. Isso seria um bug do compilador. Ainda não vejo um caso em que o bug de estouro possa ser mascarado.

talvez isso te ajude:

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

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

java (int * int, desculpe, não encontrei int64 em 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. salve o resultado em tipo grande (int * int coloque o resultado em long, long * long coloque em int64)

2.cmp result >> bits e result >> (bits - 1)