java.lang.ArithmeticException: integer overflow
Un calcul cu Math.addExact, multiplyExact sau toIntExact a depășit valoarea maximă a lui Int (2147483647). Funcțiile Exact aruncă excepția ca să nu primești un rezultat greșit. Fă calculul în Long (sau BigInteger pentru valori uriașe).
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Int în Kotlin are 32 de biți: maximul este 2.147.483.647. Operațiile obișnuite (+, *) nu dau eroare la depășire: rezultatul „se întoarce” în negative (Int.MAX_VALUE + 1 devine -2.147.483.648), fără niciun avertisment.
Funcțiile Math.addExact, Math.multiplyExact, Math.subtractExact, Math.incrementExact și Math.toIntExact fac aceleași operații, dar verifică depășirea și aruncă ArithmeticException: integer overflow (sau long overflow pentru Long). Le întâlnești în cod care lucrează cu bani, cantități, timpi în milisecunde sau factoriale, unde un rezultat greșit e mai rău decât o excepție.
Dacă primești eroarea, valorile tale au depășit Int: treci la Long.
De ce apare: cauzele frecvente
1Total în bani calculat în Int
fun main() {
val pretBani = 150_000_000
val total = Math.multiplyExact(pretBani, 20)
println(total)
}fun main() {
val pretBani = 150_000_000L
val total = Math.multiplyExact(pretBani, 20L)
println(total)
}Cu Long, maximul e aproximativ 9.2 x 10^18, deci produsul încape.
2Conversie din Long în Int
fun main() {
val ms = 3_000_000_000L
val n: Int = Math.toIntExact(ms)
println(n)
}fun main() {
val ms = 3_000_000_000L
val n: Long = ms
println(n)
}3 miliarde nu încap în Int; păstrează valoarea ca Long.
Repară eroarea, direct în pagină
Programul de mai jos calculează în bani (subdiviziuni) valoarea unui lot mare de produse folosind Math.multiplyExact, dar se oprește cu java.lang.ArithmeticException: integer overflow. Repară tipurile ca să încapă rezultatul și programul să afișeze Valoare lot: 3000000000 bani.
fun main() {
val pretBani = 150_000
val bucati = 20_000
val valoare = Math.multiplyExact(pretBani, bucati)
println("Valoare lot: $valoare bani")
}Valoare lot: 3000000000 bani
Indiciu
Folosește Long: pune L după literalii numerici.
Reparația
fun main() {
val pretBani = 150_000L
val bucati = 20_000L
val valoare = Math.multiplyExact(pretBani, bucati)
println("Valoare lot: $valoare bani")
}De ce merge
150.000 x 20.000 = 3.000.000.000, peste maximul lui Int (2.147.483.647). multiplyExact pe Int detectează depășirea și aruncă excepția. Cu literali Long (150_000L), se apelează varianta pentru Long, care are loc pentru rezultat. Fără multiplyExact, înmulțirea în Int ar fi dat în tăcere un număr negativ, o eroare mult mai greu de găsit.
Alte forme ale mesajului
Exception in thread "main" java.lang.ArithmeticException: integer overflowjava.lang.ArithmeticException: long overflowjava.lang.ArithmeticException: BigInteger would overflow supported range
Cum o eviți pe viitor
Pentru sume de bani, durate în milisecunde, ID-uri și contoare mari, folosește Long de la început (literal 0L). Pentru calcule financiare exacte, folosește BigDecimal. Funcțiile ...Exact sunt utile tocmai ca plasă de siguranță: păstrează-le în codul critic, ca o depășire să se vadă imediat, nu să producă sume negative.
Întrebări frecvente
De ce Int.MAX_VALUE + 1 nu dă eroare?
Pe JVM, aritmetica întreagă obișnuită se face modulo 2^32, fără verificări, din motive de viteză. Rezultatul devine negativ. Doar funcțiile ...Exact verifică.
Ce fac dacă nici Long nu ajunge?
Folosește java.math.BigInteger (întregi oricât de mari) sau BigDecimal (cu zecimale). Sunt mai lente, dar nu au limită practică.
Erori înrudite
java.lang.NumberFormatException: Value out of range. Value:"300" Radix:10 Textul e un număr valid, dar prea mare (sau prea mic) pentru tipul în care îl convertești: "300".toByte() (Byte merge până la 127), "40000".toShort(). Folosește un tip mai mare (toInt, toLong) sau varianta toByteOrNull() și tratează null. java.lang.ArithmeticException: / by zero Ai împărțit un număr întreg (Int sau Long) la 0, cu / sau %. Împărțirea întreagă la zero nu are rezultat, deci programul se oprește. Verifică împărțitorul înainte (if (n == 0) ...) sau tratează cazul cu o valoare implicită. java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result. Ai împărțit două BigDecimal fără să spui câte zecimale vrei, iar rezultatul are zecimale infinite (10 / 3 = 3.333...). Dă scala și modul de rotunjire: a.divide(b, 2, RoundingMode.HALF_UP). Învață Kotlin de la zero, cu exerciții la fiecare lecție
Curs Kotlin (Android): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
