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

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

static final int safeAdd(int left, int right)
                 throws ArithmeticException {
  if (right > 0 ? left > Integer.MAX_VALUE - right
                : left < Integer.MIN_VALUE - right) {
    throw new ArithmeticException("Integer overflow");
  }
  return left + right;
}

static final int safeSubtract(int left, int right)
                 throws ArithmeticException {
  if (right > 0 ? left < Integer.MIN_VALUE + right
                : left > Integer.MAX_VALUE + right) {
    throw new ArithmeticException("Integer overflow");
  }
  return left - right;
}

static final int safeMultiply(int left, int right)
                 throws ArithmeticException {
  if (right > 0 ? left > Integer.MAX_VALUE/right
                  || left < Integer.MIN_VALUE/right
                : (right < -1 ? left > Integer.MIN_VALUE/right
                                || left < Integer.MAX_VALUE/right
                              : right == -1
                                && left == Integer.MIN_VALUE) ) {
    throw new ArithmeticException("Integer overflow");
  }
  return left * right;
}

static final int safeDivide(int left, int right)
                 throws ArithmeticException {
  if ((left == Integer.MIN_VALUE) && (right == -1)) {
    throw new ArithmeticException("Integer overflow");
  }
  return left / right;
}

static final int safeNegate(int a) throws ArithmeticException {
  if (a == Integer.MIN_VALUE) {
    throw new ArithmeticException("Integer overflow");
  }
  return -a;
}
static final int safeAbs(int a) throws ArithmeticException {
  if (a == Integer.MIN_VALUE) {
    throw new ArithmeticException("Integer overflow");
  }
  return Math.abs(a);
}

我想这应该没问题。

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

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

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

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

有一种情况，上面没有提到:

int res = 1;
while (res != 0) {
    res *= 2;

}
System.out.println(res);

会产生:

0

本案例讨论如下: 整数溢出产生零。