Làm cách nào để kiểm tra xem việc nhân hai số trong Java có gây ra lỗi tràn không?

Tôi muốn xử lý trường hợp đặc biệt khi nhân hai số với nhau gây ra tràn. Mã trông giống như sau:

int a = 20;
long b = 30;

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

Đó là một phiên bản đơn giản hóa. Trong chương trình thực avà bcó nguồn ở nơi khác trong thời gian chạy. Những gì tôi muốn đạt được là một cái gì đó như thế này:

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

Làm thế nào để bạn đề nghị tôi viết mã này tốt nhất?

Cập nhật: avà bluôn không tiêu cực trong kịch bản của tôi.

Java 8 có Math.multiplyExact, Math.addExactv.v. cho int và dài. Những thứ này tạo ra một ArithmeticExceptiontràn không được kiểm soát .

Nếu avà bcả hai đều tích cực thì bạn có thể sử dụng:

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

Nếu bạn cần xử lý cả số dương và số âm thì phức tạp hơn:

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
}

Đây là một bảng nhỏ mà tôi đã thu thập để kiểm tra điều này, giả sử rằng tràn xảy ra ở -10 hoặc +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

Có các thư viện Java cung cấp các phép toán số học an toàn, giúp kiểm tra dòng tràn / dòng dưới dài. Ví dụ: LongMath.checkedMultiply của Guava (long a, long b) trả về tích của avà b, miễn là nó không bị tràn và ném ArithmeticExceptionnếu a * btràn trong longsố học có dấu.

Bạn có thể sử dụng java.math.BigInteger để thay thế và kiểm tra kích thước của kết quả (chưa kiểm tra mã):

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

Sử dụng logarit để kiểm tra kích thước của kết quả.

Java có một cái gì đó giống như int.MaxValue? Nếu có, thì hãy thử

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

chỉnh sửa: đã thấy Long.MAX_VALUE được đề cập

Đây là cách đơn giản nhất tôi có thể nghĩ ra

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

Bị đánh cắp từ jruby

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

CẬP NHẬT: Mã này ngắn và hoạt động tốt; tuy nhiên, nó không thành công cho a = -1, b = Long.MIN_VALUE.

Một cải tiến có thể có:

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

Lưu ý rằng điều này sẽ bắt một số tràn mà không có bất kỳ sự phân chia nào.

Như đã được chỉ ra, Java 8 có các phương thức Math.xxxExact để loại bỏ các ngoại lệ khi tràn.

Nếu bạn không sử dụng Java 8 cho dự án của mình, bạn vẫn có thể "mượn" các triển khai của chúng khá nhỏ gọn.

Dưới đây là một số liên kết đến các triển khai này trong kho lưu trữ mã nguồn JDK, không có gì đảm bảo liệu chúng sẽ vẫn hợp lệ nhưng trong mọi trường hợp, bạn có thể tải xuống nguồn JDK và xem cách chúng thực hiện phép thuật bên trong java.lang.Mathlớp.

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

Vân vân.

CẬP NHẬT: loại bỏ các liên kết không hợp lệ đến trang web của bên thứ 3 thành các liên kết đến các kho lưu trữ Mercurial của Open JDK.

Tôi không chắc tại sao không ai xem xét giải pháp như:

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

Chọn một lớn hơn trong hai số.

Tôi muốn xây dựng câu trả lời của John Kugelman mà không thay thế nó bằng cách chỉnh sửa trực tiếp. Nó hoạt động cho trường hợp thử nghiệm của anh ấy ( MIN_VALUE = -10, MAX_VALUE = 10) vì tính đối xứng của MIN_VALUE == -MAX_VALUE, điều này không đúng với trường hợp số nguyên bù của hai. Trong thực tế 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)

Khi được áp dụng cho true MIN_VALUEvà MAX_VALUE, câu trả lời của John Kugelman tạo ra trường hợp tràn khi a == -1và b ==bất kỳ điều gì khác (điểm đầu tiên được Kyle nêu ra). Đây là một cách để khắc phục nó:

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ó không phải là một giải pháp chung cho bất kỳ MIN_VALUEvà MAX_VALUE, nhưng nó là chung cho Java Longvà Integervà bất kỳ giá trị avà b.

Có lẽ:

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

Không chắc chắn về "giải pháp" này.

Chỉnh sửa: Đã thêm b! = 0.

Trước khi bạn phản đối : a * b / b sẽ không được tối ưu hóa. Đây sẽ là lỗi trình biên dịch. Tôi vẫn chưa thấy trường hợp nào có thể che được lỗi tràn.

Có lẽ điều này sẽ giúp bạn:

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

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

java (int * int, xin lỗi tôi không tìm thấy int64 trong 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. lưu kết quả ở kiểu lớn (int * int đặt kết quả thành long, long * long đưa vào int64)

2.cmp kết quả >> bit và kết quả >> (bit - 1)