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내 시나리오에서 음이 아닌 항상이다.

자바 (8)이 Math.multiplyExact, Math.addExactint 치의과 긴 등. 이것들은 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 라이브러리가 있습니다. 예를 들어 Guava의 LongMath.checkedMultiply (long a, long b) 는 오버플로되지 않는 경우 aand 의 곱을 반환하고 부호있는 산술 에서 오버플로 b가 ArithmeticException발생하면 throw 합니다 .a * blong

대신 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의 답변을 직접 편집하여 대체하지 않고 작성하고 싶습니다. 2의 보수 정수의 경우가 아닌 대칭으로 인해 그의 테스트 케이스 ( 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)

true MIN_VALUE및에 적용될 때 MAX_VALUEJohn Kugelman의 답변은 when a == -1and any other 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하지만 자바의의 일반입니다 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 ++ (long * long) :

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)