In Java, we can divide two numbers using the division operator (`'/'`

) as part of simple mathematics. **Beginning Java 18, we can use Math.divideExact() method that throws an ArithmeticException if the result overflows.**

## 1. The Overflow Problem

Let us begin with a simple example of division in Java. We are dividing 100 by -1. The result is -100. This is a straightforward use case that works as expected.

```
int result = 100 / -1;
System.out.println(result); // -100
```

Let’s make it more complex and use division on large numbers. We are dividing the *Integer.MIN_VALUE* value with *-1* which results in *-2,147,483,648*. This is an incorrect result.

```
int maxInteger = Integer.MAX_VALUE; // 2,147,483,647
int minInteger = Integer.MIN_VALUE; // -2,147,483,648
int quotient = minInteger / -1; // -2,147,483,648
```

The above result is incorrect because it should be the +2,147,483,648 which doesn’t fit in the *int* domain. The *int* domain was overflowed and resulted in `|Integer.MIN_VALUE| > |Integer.MAX_VALUE|`

(comparing absolute values).

The same problem will also appear for *long* datatype when we use *Long.MIN_VALUE*. The following division is also incorrect and should have produced a positive number.

```
long y = Long.MIN_VALUE; // -9,223,372,036,854,775,808
long quotient = y / -1; // -9,223,372,036,854,775,808
```

## 2. The Solution: Math.divideExact()

Starting with JDK 18, the Math class has two additional *divideExact()* methods – one for *int* and the second for *long* datatype.

```
public static int divideExact(int x, int y)
public static long divideExact(long x, long y)
```

These methods return the quotient of the arguments as expected. Additionally, these methods throw an *ArithmeticException*:

- if the result overflows
- if y (divisor) is zero

To be precise, the overflow occurs in this method ONLY IF x is *Integer.MIN_VALUE* and y is *-1*. In such cases, these methods throw *ArithmeticException* instead of returning a misleading result.

```
int quotientExactFine = Math.divideExact(4, -1);
System.out.println(quotientExactFine);
int quotientExactEx = Math.divideExact(x, -1);
System.out.println(quotientExactEx);
```

The program output:

```
-4
Exception in thread "main" java.lang.ArithmeticException: integer overflow
at java.base/java.lang.Math.divideExact(Math.java:1065)
at com.howtodoinjava.core.basic.math.MathDivideExact.main(MathDivideExact.java:25)
```

## 3. Conclusion

As discussed in this tutorial, the *Math.divideExact()* method is very useful if the division result is prone to overflowing the *int* or *long* (as *Integer.MIN_VALUE*/*Long.MIN_VALUE* overflows the positive range).

It is worth remembering to use *BigInteger* and *BigDecimal* classes when working with large numbers that support values in the range -2^{Integer.MAX_VALUE} (exclusive) to +2^{Integer.MAX_VALUE} (exclusive) and practically it is impossible to cross this limit in a real-world application.

Happy Learning !!

## Comments