如何检查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等，为整数且长。这些会引发未经检查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（long a，long b）返回aand 的乘积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"
}

从Jruby被盗

    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

等等等

更新：切换到第三方网站的无效链接，以链接到Open JDK的Mercurial存储库。

我不确定为什么没人在看这样的解决方案：

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约翰Kugelman的回答时，产生溢出的情况下a == -1和b ==别的（点由凯尔首次提出）。这是一种解决方法：

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和的任意值a和b。

也许：

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，很抱歉，我在Java中找不到int64）：

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）