# Java Math Class: java.lang.Math

Use the Math class, part of java.lang.Math. Call Math.floor, ceil and other methods.**Math.** A drop of water falls to the ground. It lands near a carved stone—this tablet is covered with mathematical works. Our world conceals many things.

**In Java** we need no stone tablets—we use the Math class. It has high-quality methods. It computes simple things like absolute values, to complex ones like cube roots.

**Math.E, PI.** Sometimes programs need to use the E and pi constants. With the Math class, we can access these as fields. We do not need to specify 3.14 for pi.

**Tip:** Using these included constants results in much clearer code—and no mistakes in the value of pi.

**Java program that gets Math.E, PI**
public class Program {
public static void main(String[] args) {*
// Get these known constants.
*double value1 = __Math.E__;
double value2 = __Math.PI__;
System.out.println(value1);
System.out.println(value2);
}
}
**Output**
2.718281828459045
3.141592653589793

**Exact methods.** The Math class provides "exact" methods. These do what we expect (add, subtract, multiply) but throw an ArithmeticException when the result overflows.

**So:** In a computation where overflow would be disastrous, these methods help check that the program is correct.

**Tip:** An exception is easier to debug than an unusual result from a mathematical computation, which may just cause incorrect output.

**Java program that uses addExact, exact methods**
import java.lang.Math;
public class Program {
public static void main(String[] args) {*
// Use exact methods.
*int result1 = __Math.addExact__(1, 1);
int result2 = Math.addExact(100, 1);
int result3 = Math.subtractExact(100, 1);
int result4 = Math.multiplyExact(5, 4);
int result5 = Math.incrementExact(2);
int result6 = Math.decrementExact(1000);
int result7 = Math.negateExact(100);*
// Display our results.
*System.out.println(result1 + *" "* + result2 + *" "* + result3 + *" "*
+ result4 + *" "* + result5 + *" "* + result6 + *" "* + result7);*
// An ArithmeticException is thrown if a number overflows.
*try {
int invalid = Math.multiplyExact(Integer.MAX_VALUE, 100);
} catch (Exception ex) {
System.out.println(ex);
}
}
}
**Output**
2 101 99 20 3 999 -100
java.lang.ArithmeticException: integer overflow

**Math.toIntExact.** The Math class has some conversion methods. Here, we use toIntExact, which converts along value to an int. The int must be able to store the long's value.

**Example:** The value 100 can be stored in an int, so the first toIntExact call succeeds. But Long.MAX_VALUE cannot be stored in an int.

**Java program that uses Math.toIntExact**
import java.lang.Math;
public class Program {
public static void main(String[] args) {*
// An int can store the value 100.
*long test = 100;
int result = Math.__toIntExact__(test);
System.out.println(*"INT: "* + result);*
// This will cause an exception, as the int cannot store the value.
*test = Long.MAX_VALUE;
result = Math.__toIntExact__(test);
}
}
**Output**
INT: 100
Exception in thread "main" java.lang.ArithmeticException: integer overflow
at java.base/java.lang.Math.toIntExact(Math.java:1071)
at Program.main(Program.java:13)

**Abs.** A number is -1. With the Math.abs method, we take its absolute value. So negative one is transformed into one. Positive numbers are left unchanged.

Math.abs

**Floor.** When we take the floor of a number we get the nearest, lower integral value. So the floor of 4.9 is 4. We can use Math.floor, floorDiv and floorMod.

Math.floor**Ceiling:** The ceiling of 4.1 is 5. With Math.ceil in Java we compute the ceiling function for floating-point numbers.

Math.ceil

**Square root.** Imagine a square. It has an area. With the square root function, we map its area (a number) to the length of one of its sides.

Math.sqrt**Math.max, min.** These methods receive two numeric arguments. Math.max returns the higher of the two arguments. And Math.min returns the lower one.

Math.max**Math.pow.** With this method we use exponents. We can square numbers by raising a number to the power of 2. The second argument to Math.pow is the exponent.

Math.pow**Random.** We use the Math.random method to get a pseudo-random number. Internally this method creates a Random class instance. It makes using random numbers easier.

Random**Math.round.** With doubles and floats we have numbers like 10.5 and 10.9. Theses are often "rounded up" to 10. With Math.round we have an efficient way to round numbers.

Math.round**Truncate.** There is no Math.truncate method in Java 8. But we can create a truncate method that combines Math.ceil and Math.floor with good results for both positive and negative numbers.

Truncate Number**Compound interest.** We use Math.pow() to compute compound interest, which is an exponential function. Investment interest compounds at different rates (schedules).

Compound Interest**With abstraction,** we conceal incredible levels of complexity. This is called information hiding. With the Math class, we use declarative method calls to compute values.

**As developers,** we can avoid implementing this code ourselves. Instead we use prebuilt, tested, optimized methods. In most cases (not all) this approach is best.

© 2007-2019 Sam Allen. Every person is special and unique. Send bug reports to info@dotnetperls.com.