[java] Java는 정수 언더 플로 및 오버플로를 어떻게 처리하며 어떻게 확인합니까?

음, 원시 정수 유형에 이르기까지 Java는 Over / Underflow를 전혀 처리하지 않습니다 (float과 double의 동작이 다르면 IEEE-754 명령과 같이 +/- 무한대로 플러시됩니다).

두 개의 int를 추가하면 오버플로가 발생해도 표시되지 않습니다. 오버플로를 확인하는 간단한 방법은 다음으로 큰 유형을 사용하여 실제로 작업을 수행하고 결과가 여전히 소스 유형의 범위에 있는지 확인하는 것입니다.

public int addWithOverflowCheck(int a, int b) {
    // the cast of a is required, to make the + work with long precision,
    // if we just added (a + b) the addition would use int precision and
    // the result would be cast to long afterwards!
    long result = ((long) a) + b;
    if (result > Integer.MAX_VALUE) {
         throw new RuntimeException("Overflow occured");
    } else if (result < Integer.MIN_VALUE) {
         throw new RuntimeException("Underflow occured");
    }
    // at this point we can safely cast back to int, we checked before
    // that the value will be withing int's limits
    return (int) result;
}

throw 절 대신 수행 할 작업은 응용 프로그램 요구 사항에 따라 다릅니다 (던지기, 최소 / 최대로 플러시 또는 아무 것도 기록). 긴 작업에서 오버플로를 감지하려면 프리미티브를 사용하는 것이 좋지 않습니다. 대신 BigInteger를 사용하십시오.

편집 (2014-05-21) :이 질문은 자주 언급되는 것처럼 보이며 동일한 문제를 직접 해결해야했기 때문에 CPU가 V 플래그를 계산하는 것과 동일한 방법으로 오버플로 조건을 평가하기가 쉽습니다.

기본적으로 결과와 함께 두 피연산자의 부호를 포함하는 부울 표현식입니다.

/**
 * Add two int's with overflow detection (r = s + d)
 */
public static int add(final int s, final int d) throws ArithmeticException {
    int r = s + d;
    if (((s & d & ~r) | (~s & ~d & r)) < 0)
        throw new ArithmeticException("int overflow add(" + s + ", " + d + ")");
    return r;
}

Java에서 표현식을 if의 전체 32 비트에 적용하고 <0을 사용하여 결과를 확인하는 것이 더 간단합니다 (이는 부호 비트를 효과적으로 테스트합니다). 원리는 모든 정수 기본 유형에 대해 정확히 동일하게 작동 하며 위의 메소드에서 모든 선언을 long으로 변경하면 오래 작동합니다.

더 작은 유형의 경우 int 로의 암시 적 변환으로 인해 (자세한 내용은 비트 단위 연산에 대해서는 JLS 참조) <0을 검사하는 대신 검사 비트를 명시 적으로 마스크해야합니다 (짧은 피연산자의 경우 0x8000, 바이트 피연산자의 경우 0x80, 캐스트 조정). 적절하게 매개 변수 선언) :

/**
 * Subtract two short's with overflow detection (r = d - s)
 */
public static short sub(final short d, final short s) throws ArithmeticException {
    int r = d - s;
    if ((((~s & d & ~r) | (s & ~d & r)) & 0x8000) != 0)
        throw new ArithmeticException("short overflow sub(" + s + ", " + d + ")");
    return (short) r;
}

(위의 예는 빼기 오버플로 감지에 필요한 표현을 사용합니다 )

그렇다면 이러한 부울 표현식은 어떻게 / 왜 작동합니까? 첫째, 일부 논리적 사고는 두 인수의 부호가 동일한 경우 에만 오버플로가 발생할 수 있음을 나타냅니다 . 하나의 인수가 음수이고 하나의 양수인 경우 추가의 결과 는 0에 가까워 지거나 극단적 인 경우 하나의 인수는 다른 인수와 같은 0이어야합니다. 스스로 인수가 있기 때문에 할 수없는 오버 플로우 조건을 만들고, 그 합은 하나 오버 플로우를 만들 수 없습니다.

두 인수 모두 같은 부호를 가지면 어떻게됩니까? MAX_VALUE 유형보다 더 큰 합계를 생성하는 두 개의 인수를 추가하면 항상 음수 값이 생성되므로 arg1 + arg2> MAX_VALUE 인 경우 오버플로가 발생합니다 . 이제 발생할 수있는 최대 값은 MAX_VALUE + MAX_VALUE입니다 (극단의 경우 두 인수 모두 MAX_VALUE). 127 + 127 = 254를 의미하는 바이트 (예)의 경우 두 개의 양수 값을 추가하여 발생할 수있는 모든 값의 비트 표현을 살펴보면 오버플로 된 (128-254) 비트가 모두 7로 설정되어 있음을 알 수 있습니다. 오버플로되지 않는 (0-127) 비트 7 (맨 위, 부호)이 지워졌습니다. 그것이 표현식의 첫 번째 (오른쪽) 부분이 정확히 확인하는 것입니다.

if (((s & d & ~r) | (~s & ~d & r)) < 0)

(~ s & ~ d & r)은 피연산자 (s, d) 모두 양수이고 결과 (r)가 음수 인 경우에만 적용됩니다 (표현식은 모든 32 비트에서 작동하지만 우리가 관심있는 유일한 비트는 가장 최상위 (부호) 비트이며 <0에 의해 검사됩니다).

이제 두 인수가 모두 음수이면 합계가 인수보다 0에 가까워 질 수 없으며, 합계 는 마이너스 무한대에 가까워 야합니다 . 우리가 생성 할 수있는 가장 극단적 인 값은 MIN_VALUE + MIN_VALUE이며, 바이트 예제의 경우 범위 값 (-1 ~ -128)에 대해 부호 비트가 설정되어 있지만 오버플로 값 (-129 ~ -256)이 표시됩니다 )의 부호 비트가 지워졌습니다. 따라서 결과의 부호는 다시 오버플로 조건을 나타냅니다. 왼쪽 절반 (s & d & ~ r)은 두 인수 (s, d)가 모두 음수이고 결과가 긍정적 인 경우를 확인합니다. 논리는 긍정적 인 경우와 거의 같습니다. 두 개의 음수 값을 추가하여 발생할 수있는 모든 비트 패턴 은 언더 플로가 발생한 경우에만 부호 비트가 지워집니다 .

답변

int bigValue = Integer.MAX_VALUE;
int x = bigValue * 2 / 5;
int y = bigValue / x;

int bigValue = Integer.MAX_VALUE;
int x = bigValue / 5 * 2;
int y = bigValue / x;

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

public class Test {

    public static void main(String[] args) {
        int i = Integer.MAX_VALUE;
        int j = Integer.MIN_VALUE;

        System.out.println(i+1);
        System.out.println(j-1);
    }
}

-2147483648
2147483647