### Java Math ceilDivExact() Method

The `Math.ceilDivExact()` method in Java is used to perform division and return the smallest (closest to negative infinity) value that is greater than or equal to the algebraic quotient. If the result overflows the range of the type, an `ArithmeticException` is thrown.

1. Introduction
2. `ceilDivExact()` Method Syntax
3. Overloaded `ceilDivExact()` Methods
4. Examples
• `ceilDivExact(int x, int y)`
• `ceilDivExact(long x, long y)`
5. Real-World Use Case
6. Conclusion

## Introduction

The `Math.ceilDivExact()` method provides a way to perform division and ensure that the result is rounded up to the nearest integer value, with an overflow check. This is useful in scenarios where you need to divide two numbers and ensure that the result is always rounded up, and any overflow is detected and handled.

## ceilDivExact() Method Syntax

The syntax for the `ceilDivExact()` method varies depending on the types of the arguments:

### `ceilDivExact(int x, int y)`

``````public static int ceilDivExact(int x, int y)
``````

### `ceilDivExact(long x, long y)`

``````public static long ceilDivExact(long x, long y)
``````

### Parameters:

• `x`: The dividend.
• `y`: The divisor.

### Returns:

• The smallest value that is greater than or equal to the algebraic quotient.

### Throws:

• `ArithmeticException` if the divisor `y` is zero or if the result overflows the positive range of the type.

The `Math.ceilDivExact()` method is overloaded to handle different primitive data types: `int` and `long`. Each version returns the quotient of the division, rounded up to the nearest integer value, and throws an `ArithmeticException` if the result overflows.

## Examples

### `ceilDivExact(int x, int y)`

The `ceilDivExact(int x, int y)` method returns the quotient of two `int` values, rounded up to the nearest integer value, and throws an `ArithmeticException` if the result overflows.

#### Example

``````public class CeilDivExactIntExample {
public static void main(String[] args) {
int x1 = 7, y1 = 3;
int x2 = Integer.MAX_VALUE, y2 = 1;
int x3 = Integer.MIN_VALUE, y3 = -1;

try {
int result1 = Math.ceilDivExact(x1, y1);
System.out.println("Ceiling division of " + x1 + " / " + y1 + " is " + result1);
} catch (ArithmeticException e) {
System.out.println("Overflow occurred for division: " + x1 + " / " + y1);
}

try {
int result2 = Math.ceilDivExact(x2, y2);
System.out.println("Ceiling division of " + x2 + " / " + y2 + " is " + result2);
} catch (ArithmeticException e) {
System.out.println("Overflow occurred for division: " + x2 + " / " + y2);
}

try {
int result3 = Math.ceilDivExact(x3, y3);
System.out.println("Ceiling division of " + x3 + " / " + y3 + " is " + result3);
} catch (ArithmeticException e) {
System.out.println("Overflow occurred for division: " + x3 + " / " + y3);
}
}
}
``````

Output:

``````Ceiling division of 7 / 3 is 3
Ceiling division of 2147483647 / 1 is 2147483647
Overflow occurred for division: -2147483648 / -1
``````

### `ceilDivExact(long x, long y)`

The `ceilDivExact(long x, long y)` method returns the quotient of two `long` values, rounded up to the nearest integer value, and throws an `ArithmeticException` if the result overflows.

#### Example

``````public class CeilDivExactLongExample {
public static void main(String[] args) {
long x1 = 10L, y1 = 3L;
long x2 = Long.MAX_VALUE, y2 = 1L;
long x3 = Long.MIN_VALUE, y3 = -1L;

try {
long result1 = Math.ceilDivExact(x1, y1);
System.out.println("Ceiling division of " + x1 + " / " + y1 + " is " + result1);
} catch (ArithmeticException e) {
System.out.println("Overflow occurred for division: " + x1 + " / " + y1);
}

try {
long result2 = Math.ceilDivExact(x2, y2);
System.out.println("Ceiling division of " + x2 + " / " + y2 + " is " + result2);
} catch (ArithmeticException e) {
System.out.println("Overflow occurred for division: " + x2 + " / " + y2);
}

try {
long result3 = Math.ceilDivExact(x3, y3);
System.out.println("Ceiling division of " + x3 + " / " + y3 + " is " + result3);
} catch (ArithmeticException e) {
System.out.println("Overflow occurred for division: " + x3 + " / " + y3);
}
}
}
``````

Output:

``````Ceiling division of 10 / 3 is 4
Ceiling division of 9223372036854775807 / 1 is 9223372036854775807
Overflow occurred for division: -9223372036854775808 / -1
``````

## Real-World Use Case

### Safe Arithmetic Calculations

In real-world scenarios, the `Math.ceilDivExact()` method can be used to perform safe arithmetic calculations where it is crucial to handle potential overflow situations. This can be particularly useful in financial applications, data processing, and any other scenarios where accurate arithmetic operations are necessary.

#### Example

``````public class SafeArithmeticExample {
public static void main(String[] args) {
long dividend = Long.MAX_VALUE;
long divisor = 1L;

try {
long quotient = Math.ceilDivExact(dividend, divisor);
System.out.println("The quotient of " + dividend + " divided by " + divisor + " is " + quotient);
} catch (ArithmeticException e) {
System.out.println("Overflow occurred for division: " + dividend + " / " + divisor);
}
}
}
``````

Output:

``````The quotient of 9223372036854775807 divided by 1 is 9223372036854775807
``````

## Conclusion

The `Math.ceilDivExact()` method in Java provides a way to perform division with rounding up, ensuring that the result is the smallest integer greater than or equal to the algebraic quotient, with overflow detection. By understanding how to use this method and its overloaded versions, you can perform various division operations and handle potential overflow issues in your Java applications.

Whether you are working with integers or long integers, the `ceilDivExact()` method offers a reliable tool for ensuring correct division results and safe arithmetic calculations.