ฉันจะตรวจสอบได้อย่างไรว่าการคูณสองตัวเลขใน Java จะทำให้ล้นหรือไม่

ฉันต้องการจัดการกรณีพิเศษที่การคูณสองจำนวนเข้าด้วยกันทำให้เกิดการล้น รหัสมีลักษณะดังนี้:

int a = 20;
long b = 30;

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

นั่นเป็นเวอร์ชันที่เรียบง่าย ในโปรแกรมจริงaและbมีที่มาจากที่อื่นในรันไทม์ สิ่งที่ฉันต้องการบรรลุมีดังนี้:

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

คุณจะแนะนำให้ฉันตั้งรหัสนี้ได้อย่างไร

อัปเดต: aและbมักจะไม่เป็นลบในสถานการณ์ของฉัน

Java 8 มีMath.multiplyExact, Math.addExactฯลฯ สำหรับ ints และระยะยาว สิ่งเหล่านี้ทำให้เกิดการArithmeticExceptionล้น

หากaและbเป็นบวกทั้งคู่คุณสามารถใช้:

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

หากคุณต้องการจัดการกับตัวเลขทั้งบวกและลบมันซับซ้อนกว่านี้:

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
}

นี่คือตารางเล็ก ๆ ที่ฉันตีขึ้นเพื่อตรวจสอบสิ่งนี้โดยแกล้งทำเป็นว่าล้นเกิดขึ้นที่ -10 หรือ +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

มีไลบรารี Java ที่ให้การดำเนินการทางคณิตศาสตร์ที่ปลอดภัยซึ่งตรวจสอบการล้น / การไหลที่ไม่ยาว ตัวอย่างเช่นLongMath.checkedMultiplyของ Guava (long a, long b)จะส่งคืนผลคูณของaและbหากไม่ล้นและพ่นArithmeticExceptionหากมีจำนวนมากเกินไปa * bในlongเลขคณิตที่ลงนาม

คุณสามารถใช้ java.math.BigInteger แทนและตรวจสอบขนาดของผลลัพธ์ (ยังไม่ได้ทดสอบโค้ด):

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

ใช้ลอการิทึมเพื่อตรวจสอบขนาดของผลลัพธ์

Java มีบางอย่างเช่น int.MaxValue หรือไม่? ถ้าใช่ก็ลองดู

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

แก้ไข: เห็น Long.MAX_VALUE ที่มีปัญหา

นี่คือวิธีที่ง่ายที่สุดที่ฉันคิดได้

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

ขโมยมาจากป่าช้า

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

อัปเดต: รหัสนี้สั้นและใช้งานได้ดี อย่างไรก็ตามมันล้มเหลวสำหรับ a = -1, b = Long.MIN_VALUE

การปรับปรุงที่เป็นไปได้อย่างหนึ่ง:

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

โปรดทราบว่าสิ่งนี้จะทำให้เกิดการล้นบางส่วนโดยไม่มีการแบ่งส่วนใด ๆ

ดังที่ได้กล่าวไปแล้ว Java 8 มีเมธอด Math.xxxExact ที่ทำให้เกิดข้อยกเว้นในการโอเวอร์โฟลว์

หากคุณไม่ได้ใช้ Java 8 สำหรับโปรเจ็กต์ของคุณคุณยังสามารถ "ยืม" การนำไปใช้งานได้ซึ่งค่อนข้างกะทัดรัด

ต่อไปนี้คือลิงก์บางส่วนไปยังการใช้งานเหล่านี้ในที่เก็บซอร์สโค้ด JDK ไม่รับประกันว่าสิ่งเหล่านี้จะยังคงใช้ได้หรือไม่ แต่ในกรณีใด ๆ คุณควรจะสามารถดาวน์โหลดซอร์ส JDK และดูว่าพวกเขาใช้เวทมนตร์ในjava.lang.Mathคลาสได้อย่างไร

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

ฯลฯ ฯลฯ

อัปเดต: เปลี่ยนลิงก์ที่ไม่ถูกต้องไปยังเว็บไซต์ของบุคคลที่สามเป็นลิงก์ไปยังที่เก็บ Mercurial ของ Open JDK

ฉันไม่แน่ใจว่าทำไมไม่มีใครมองหาวิธีแก้ปัญหาเช่น:

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

เลือกตัวเลขสองตัวที่จะใหญ่กว่า

ฉันต้องการสร้างคำตอบของ John Kugelman โดยไม่ต้องแทนที่ด้วยการแก้ไขโดยตรง มันใช้ได้กับกรณีทดสอบของเขา ( MIN_VALUE = -10, MAX_VALUE = 10) เนื่องจากความสมมาตรMIN_VALUE == -MAX_VALUEซึ่งไม่ใช่กรณีของจำนวนเต็มบวกของสองตัว ในความเป็นจริง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)

เมื่อนำไปใช้กับจริงMIN_VALUEและMAX_VALUEคำตอบของ John Kugelman จะให้กรณีล้นเมื่อใดa == -1และb ==สิ่งอื่นใด (ชี้ก่อนโดย Kyle) นี่คือวิธีแก้ไข:

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
}

มันไม่ได้เป็นวิธีการแก้ปัญหาทั่วไปสำหรับการใด ๆMIN_VALUEและMAX_VALUEแต่มันเป็นข้อมูลทั่วไปของ Java LongและIntegerและความคุ้มค่าของการใด ๆและab

อาจจะ:

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

ไม่แน่ใจเกี่ยวกับ "วิธีแก้ปัญหา" นี้

แก้ไข: เพิ่ม b! = 0

ก่อนที่คุณจะลงคะแนน : a * b / b จะไม่ได้รับการปรับให้เหมาะสม นี่จะเป็นบั๊กของคอมไพเลอร์ ฉันยังไม่เห็นกรณีที่สามารถปกปิดข้อบกพร่องล้นได้

บางทีนี่อาจช่วยคุณได้:

/**
 * @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 ++ (ยาว * ยาว):

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

java (int * int ขออภัยฉันไม่พบ int64 ใน 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. บันทึกผลลัพธ์ในประเภทขนาดใหญ่ (int * int ทำให้ผลลัพธ์เป็น long, long * long ใส่ไปที่ int64)

ผลลัพธ์ 2.cmp >> บิตและผลลัพธ์ >> (บิต - 1)