Bagaimana cara memeriksa apakah mengalikan dua angka di Java akan menyebabkan luapan?

Saya ingin menangani kasus khusus di mana mengalikan dua angka bersama-sama menyebabkan luapan. Kode tersebut terlihat seperti ini:

int a = 20;
long b = 30;

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

Itu versi yang disederhanakan. Dalam program nyata adan bbersumber dari tempat lain saat runtime. Yang ingin saya capai adalah seperti ini:

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

Bagaimana saran Anda agar saya membuat kode terbaik ini?

Perbarui: adan bselalu tidak negatif dalam skenario saya.

Java 8 memiliki Math.multiplyExact, Math.addExactdll. Untuk int dan long. Ini membuang centang ArithmeticExceptionpada overflow.

Jika adan bkeduanya positif maka Anda dapat menggunakan:

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

Jika Anda perlu berurusan dengan bilangan positif dan negatif maka ini lebih rumit:

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
}

Berikut tabel kecil yang saya siapkan untuk memeriksanya, berpura-pura bahwa luapan terjadi pada -10 atau +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

Ada pustaka Java yang menyediakan operasi aritmatika yang aman, yang memeriksa long overflow / underflow. Misalnya, Guava's LongMath.checkedMultiply (long a, long b) mengembalikan produk dari adan b, asalkan tidak meluap, dan melempar ArithmeticExceptionjika a * bmeluap dalam longaritmatika bertanda tangan .

Anda dapat menggunakan java.math.BigInteger sebagai gantinya dan memeriksa ukuran hasilnya (belum menguji kode):

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

Gunakan logaritma untuk memeriksa ukuran hasil.

Apakah Java memiliki sesuatu seperti int.MaxValue? Jika ya, cobalah

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

edit: terlihat Long.MAX_VALUE yang dimaksud

Inilah cara paling sederhana yang dapat saya pikirkan

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

Dicuri dari jruby

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

UPDATE: Kode ini pendek dan berfungsi dengan baik; Namun, gagal untuk a = -1, b = Long.MIN_VALUE.

Satu peningkatan yang mungkin:

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

Perhatikan bahwa ini akan menangkap beberapa luapan tanpa pembagian apa pun.

Seperti yang telah ditunjukkan, Java 8 memiliki metode Math.xxxExact yang memunculkan pengecualian saat overflow.

Jika Anda tidak menggunakan Java 8 untuk proyek Anda, Anda masih dapat "meminjam" implementasinya yang cukup ringkas.

Berikut adalah beberapa link ke implementasi ini dalam repositori kode sumber JDK, tidak ada jaminan apakah ini akan tetap valid, tetapi bagaimanapun juga Anda harus dapat mendownload sumber JDK dan melihat bagaimana mereka melakukan keajaibannya di dalam java.lang.Mathkelas.

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

dll, dll.

DIPERBARUI: mengalihkan tautan tidak valid ke situs web pihak ketiga ke tautan ke repositori Mercurial dari Open JDK.

Saya tidak yakin mengapa tidak ada yang melihat solusi seperti:

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

Pilih a menjadi lebih besar dari dua angka.

Saya ingin mengembangkan jawaban John Kugelman tanpa menggantinya dengan mengeditnya secara langsung. Ini bekerja untuk kasus uji ( MIN_VALUE = -10, MAX_VALUE = 10) karena kesimetrisannya MIN_VALUE == -MAX_VALUE, yang bukan kasus untuk bilangan bulat komplemen dua. Sebenarnya 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)

Ketika diterapkan pada true MIN_VALUEand MAX_VALUE, jawaban John Kugelman menghasilkan kasus overflow kapan a == -1dan b ==lainnya (poin pertama kali dikemukakan oleh Kyle). Berikut cara untuk memperbaikinya:

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
}

Ini bukan solusi umum untuk MIN_VALUEdan MAX_VALUE, tetapi umum untuk Java Longdan Integerdan nilai apa pun dari adan b.

Mungkin:

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

Tidak yakin dengan "solusi" ini.

Edit: Menambahkan b! = 0.

Sebelum Anda memberi suara negatif : a * b / b tidak akan dioptimalkan. Ini akan menjadi bug kompilator. Saya masih tidak melihat kasus di mana bug luapan dapat ditutup-tutupi.

mungkin ini akan membantu Anda:

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

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

java (int * int, maaf saya tidak menemukan int64 di 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. simpan hasilnya dalam tipe besar (int * int letakkan hasilnya ke long, long * long put ke int64)

2. hasil cmp >> bit dan hasil >> (bit - 1)