Java'da iki sayıyı çarpmanın taşmaya neden olup olmayacağını nasıl kontrol edebilirim?

İki sayıyı çarpmanın taşmaya neden olduğu özel durumu ele almak istiyorum. Kod şuna benzer:

int a = 20;
long b = 30;

// if a or b are big enough, this result will silently overflow
long c = a * b;

Bu basitleştirilmiş bir versiyon. Gerçek programda ave bçalışma zamanında başka bir yerden kaynaklanır. Başarmak istediğim şey şuna benzer:

long c;
if (a * b will overflow) {
    c = Long.MAX_VALUE;
} else {
    c = a * b;
}

Bunu en iyi nasıl kodlamamı önerirsin?

Güncelleme: ave bsenaryomda her zaman olumsuz değildir.

Java 8 sahiptir Math.multiplyExact, Math.addExactints ve uzun vb. Bunlar ArithmeticExceptiontaşma üzerine kontrolsüz bir şekilde atarlar .

Eğer ave bikisi de pozitif o zaman kullanabilirsiniz:

if (a != 0 && b > Long.MAX_VALUE / a) {
    // Overflow
}

Hem pozitif hem de negatif sayılarla uğraşmanız gerekiyorsa, o zaman daha karmaşıktır:

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
}

İşte bunu kontrol etmek için kırbaçladığım küçük bir tablo, taşmanın -10 veya +10'da gerçekleşiyormuş gibi davranarak:

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

Uzun taşma / yetersizliği kontrol eden güvenli aritmetik işlemler sağlayan Java kitaplıkları vardır. Örneğin, Guava en LongMath.checkedMultiply (uzun uzun, b) ürününü verir ave bo değil taşması ve atar Sağlanan, ArithmeticExceptioneğer a * btaşmaları imzalanan longaritmetik.

Bunun yerine java.math.BigInteger kullanabilir ve sonucun boyutunu kontrol edebilirsiniz (kodu test etmediniz):

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()
}

Sonucun boyutunu kontrol etmek için logaritma kullanın.

Java'da int.MaxValue gibi bir şey var mı? Eğer evet ise, dene

if (b != 0 && Math.abs(a) > Math.abs(Long.MAX_VALUE / b))
{
 // it will overflow
}

düzenleme: söz konusu Long.MAX_VALUE görüntülendi

İşte aklıma gelen en basit yol

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'den çalındı

    long result = a * b;
    if (a != 0 && result / a != b) {
       // overflow
    }

GÜNCELLEME: Bu kod kısa ve iyi çalışıyor; ancak, a = -1, b = Long.MIN_VALUE için başarısız olur.

Olası bir geliştirme:

long result = a * b;
if( (Math.signum(a) * Math.signum(b) != Math.signum(result)) || 
    (a != 0L && result / a != b)) {
    // overflow
}

Bunun herhangi bir bölünme olmaksızın bazı taşmaları yakalayacağını unutmayın.

Daha önce belirtildiği gibi, Java 8, taşma durumunda istisnalar atan Math.xxxExact yöntemlerine sahiptir.

Projeniz için Java 8 kullanmıyorsanız, oldukça kompakt olan uygulamalarını yine de "ödünç" alabilirsiniz.

JDK kaynak kodu havuzundaki bu uygulamalara bazı bağlantılar aşağıda verilmiştir, bunların geçerli olup olmayacağına dair bir garanti yoktur, ancak her durumda JDK kaynağını indirebilmeli ve java.lang.Mathsınıf içinde sihirlerini nasıl yaptıklarını görmelisiniz .

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

vs vs.

GÜNCELLENDİ: Açık JDK'nın Mercurial depolarına bağlantılara yönelik üçüncü taraf web sitesine geçersiz bağlantılar değiştirildi.

Neden kimsenin çözüme bakmadığından emin değilim:

if (Long.MAX_VALUE/a > b) {
     // overflows
} 

İki sayıdan daha büyük olması için a seçin.

Doğrudan düzenleyerek değiştirmeden John Kugelman'ın cevabını geliştirmek istiyorum. Simetrisi nedeniyle test durumu ( MIN_VALUE = -10, MAX_VALUE = 10) için çalışır MIN_VALUE == -MAX_VALUE, ki bu ikinin tamamlayıcı tamsayıları için geçerli değildir. Gerçekte 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)

Doğruya uygulandığında MIN_VALUEve MAX_VALUEJohn Kugelman'ın cevabı, ne zaman a == -1ve b ==başka herhangi bir şeyde bir taşma durumu ortaya çıkarır (ilk olarak Kyle tarafından ortaya atılan nokta). İşte düzeltmenin bir yolu:

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
}

Herhangi için genel bir çözüm değil MIN_VALUEve MAX_VALUEfakat Java'nın için geneldir Longve Integerve herhangi bir değer ave b.

Olabilir:

if(b!= 0 && a * b / b != a) //overflow

Bu "çözümden" emin değilim.

Düzenleme: b! = 0 eklendi.

Olumsuz oy kullanmadan önce : a * b / b optimize edilmeyecektir. Bu derleyici hatası olacaktır. Hala taşma hatasının maskelenebileceği bir durum göremiyorum.

Belki bu size yardımcı olur:

/**
 * @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 ++ (uzun * uzun):

const int64_ w = (int64_) a * (int64_) b;    
if ((long) (w >> sizeof(long) * 8) != (long) w >> (sizeof(long) * 8 - 1))
    // overflow

java (int * int, üzgünüm java'da int64 bulamadım):

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. sonucu büyük türe kaydedin (int * int sonucu long, long * long, int64'e koyun)

2.cmp sonucu >> bitler ve sonuç >> (bit - 1)