Math

In Java we use the Math class for high-quality mathematical methods. It computes simple things like absolute values, to complex ones like cube roots.

We access some constants like Math.PI directly on the Math type. And some methods like Math.addExact give us more control over arithmetic.

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.

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);
    }
}
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.

import java.lang.Math;

public class Program {
    public static void main(String[] args) {

        // Part 1: 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);
        // Part 2: display our results.
        System.out.println(result1 + " " + result2 + " " + result3 + " "
                + result4 + " " + result5 + " " + result6 + " " + result7);

        // Part 3: an ArithmeticException is thrown if a number overflows.
        try {
            int invalid = Math.multiplyExact(Integer.MAX_VALUE, 100);
        } catch (Exception ex) {
            System.out.println(ex);
        }
    }
}
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.

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);
    }
}
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.

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.

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.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.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.

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.

Summary

With the Math class, we use declarative method calls to compute values. We avoid implementing this code ourselves—instead, we use built-in methods.