Come posso verificare se la moltiplicazione di due numeri in Java provocherà un overflow?

Voglio gestire il caso speciale in cui la moltiplicazione di due numeri insieme causa un overflow. Il codice ha un aspetto simile a questo:

int a = 20;
long b = 30;

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

Questa è una versione semplificata. Nel programma reale ae bsono reperiti altrove in fase di esecuzione. Quello che voglio ottenere è qualcosa del genere:

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

Come suggerisci di codificarlo al meglio?

Aggiornamento: ae bsono sempre non negativi nel mio scenario.

Java 8 ha Math.multiplyExact, Math.addExactecc. Per int e long. Questi generano un ArithmeticExceptionoverflow non controllato .

Se ae bsono entrambi positivi, puoi usare:

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

Se devi gestire sia numeri positivi che negativi, è più complicato:

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
}

Ecco un tavolino che ho preparato per verificarlo, fingendo che l'overflow avvenga a -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

Esistono librerie Java che forniscono operazioni aritmetiche sicure, che controllano overflow / underflow lunghi. Ad esempio, LongMath.checkedMultiply di Guava (long a, long b) restituisce il prodotto di ae b, a condizione che non esegua l' overflow, e genera ArithmeticExceptionse a * boverflow longnell'aritmetica con segno.

Puoi invece usare java.math.BigInteger e controllare la dimensione del risultato (non hai testato il codice):

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

Usa i logaritmi per controllare la dimensione del risultato.

Java ha qualcosa come int.MaxValue? Se sì, allora prova

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

modifica: visto Long.MAX_VALUE in questione

Ecco il modo più semplice a cui riesco a pensare

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

Rubato a jruby

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

AGGIORNAMENTO: questo codice è breve e funziona bene; tuttavia, non riesce per a = -1, b = Long.MIN_VALUE.

Un possibile miglioramento:

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

Nota che questo catturerà alcuni overflow senza alcuna divisione.

Come è stato sottolineato, Java 8 ha metodi Math.xxxExact che generano eccezioni in caso di overflow.

Se non stai usando Java 8 per il tuo progetto, puoi comunque "prendere in prestito" le loro implementazioni che sono piuttosto compatte.

Ecco alcuni collegamenti a queste implementazioni nel repository del codice sorgente JDK, nessuna garanzia che rimarranno valide ma in ogni caso dovresti essere in grado di scaricare il sorgente JDK e vedere come fanno la loro magia all'interno della 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

ecc. ecc.

AGGIORNATO: disattivato i collegamenti non validi a siti Web di terze parti ai collegamenti ai repository Mercurial di Open JDK.

Non sono sicuro del motivo per cui nessuno sta guardando una soluzione come:

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

Scegli a per essere più grande dei due numeri.

Vorrei basarmi sulla risposta di John Kugelman senza sostituirla modificandola direttamente. Funziona per il suo test case ( MIN_VALUE = -10, MAX_VALUE = 10) a causa della simmetria di MIN_VALUE == -MAX_VALUE, che non è il caso degli interi in complemento a due. In realtà, 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 applicata al vero MIN_VALUEe MAX_VALUE, la risposta di John Kugelman produce un caso in overflow quando a == -1e b ==qualsiasi altra cosa (punto sollevato per primo da Kyle). Ecco un modo per risolverlo:

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
}

Non è una soluzione generale per qualsiasi MIN_VALUEe MAX_VALUE, ma è generale per Java Longe Integere qualsiasi valore di ae b.

Può essere:

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

Non sono sicuro di questa "soluzione".

Modifica: aggiunto b! = 0.

Prima di downvote : a * b / b non sarà ottimizzato. Questo sarebbe un bug del compilatore. Continuo a non vedere un caso in cui il bug di overflow possa essere mascherato.

forse questo ti aiuterà:

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

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

java (int * int, scusa non ho trovato int64 in 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.Salva il risultato in caratteri grandi (int * int mette il risultato a long, long * long mette a int64)

2.cmp risultato >> bit e risultato >> (bit - 1)