我想这应该没问题。

static boolean addWillOverFlow(int a, int b) {
    return (Integer.signum(a) == Integer.signum(b)) && 
            (Integer.signum(a) != Integer.signum(a+b)); 
}

我自己也遇到了这个问题，下面是我的解决方案(包括乘法和加法):

static boolean wouldOverflowOccurwhenMultiplying(int a, int b) {
    // If either a or b are Integer.MIN_VALUE, then multiplying by anything other than 0 or 1 will result in overflow
    if (a == 0 || b == 0) {
        return false;
    } else if (a > 0 && b > 0) { // both positive, non zero
        return a > Integer.MAX_VALUE / b;
    } else if (b < 0 && a < 0) { // both negative, non zero
        return a < Integer.MAX_VALUE / b;
    } else { // exactly one of a,b is negative and one is positive, neither are zero
        if (b > 0) { // this last if statements protects against Integer.MIN_VALUE / -1, which in itself causes overflow.
            return a < Integer.MIN_VALUE / b;
        } else { // a > 0
            return b < Integer.MIN_VALUE / a;
        }
    }
}

boolean wouldOverflowOccurWhenAdding(int a, int b) {
    if (a > 0 && b > 0) {
        return a > Integer.MAX_VALUE - b;
    } else if (a < 0 && b < 0) {
        return a < Integer.MIN_VALUE - b;
    }
    return false;
}

如果有错误或者可以简化，请随意纠正。我已经用乘法法做了一些测试，大部分是边缘情况，但它仍然可能是错误的。

它什么都不做——只是发生了under/overflow。

“-1”是溢出计算的结果，与任何其他信息产生的“-1”没有区别。因此，您不能通过某些状态或仅仅检查一个值来判断它是否溢出。

但是为了避免溢出，你可以聪明地进行计算，如果这很重要的话，或者至少知道什么时候会发生溢出。你的情况如何?

我想这应该没问题。

static boolean addWillOverFlow(int a, int b) {
    return (Integer.signum(a) == Integer.signum(b)) && 
            (Integer.signum(a) != Integer.signum(a+b)); 
}

我认为你应该使用这样的东西，它被称为Upcasting:

public int multiplyBy2(int x) throws ArithmeticException {
    long result = 2 * (long) x;    
    if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE){
        throw new ArithmeticException("Integer overflow");
    }
    return (int) result;
}

你可以在这里进一步阅读: 检测或防止整数溢出

这是相当可靠的来源。

有一些库提供安全的算术操作，用于检查整数溢出/下溢。例如，Guava的IntMath。checkedAdd(int a, int b)返回a和b的和，前提是它没有溢出，如果a + b在有符号int算术中溢出，则抛出arithmeexception。