Java Math Class and Utility Methods

What Is the Math Class and Why Is It final?

Math is declared public final class Math, and its only constructor is private. final stops anyone from subclassing it and changing how the methods behave, and the private constructor stops anyone from writing new Math(). There is nothing to store per object anyway: every method takes its inputs as arguments and returns a result, so they are all static and you call them as Math.methodName(...). Most methods are overloaded for int, long, float and double, and the return type usually follows the argument type.

Math Constants: Math.PI and Math.E

Math.PI (approximately 3.14159265358979) and Math.E (approximately 2.71828182845905, the base of the natural logarithm) are declared as public static final double fields, ready to use in geometric or exponential calculations without hardcoding approximations. For example, the area of a circle is Math.PI * r * r.

max(), min() and abs()

Math.max(a, b) and Math.min(a, b) return the larger or smaller of two values; to find the largest of three, nest them: Math.max(a, Math.max(b, c)). Math.abs(x) returns the absolute (non-negative) value. One edge case: Math.abs(Integer.MIN_VALUE) is still -2147483648, because the positive value does not fit in an int. Use Math.absExact() (Java 15+) if you want an exception instead.

pow(), sqrt() and cbrt(): Powers and Roots

• Math.pow(base, exponent) raises base to the given exponent and always returns a double, so int x = (int) Math.pow(2, 3); needs a cast.
• Math.sqrt(x) returns the square root as a double; a negative input returns NaN rather than throwing.
• Math.cbrt(x) returns the cube root and, unlike sqrt, works for negative numbers: Math.cbrt(-27) is -3.0.

round() vs ceil() vs floor() vs rint()

All four turn a decimal into a whole number, but they disagree on direction, on ties, and on the return type. Negative numbers are where most mistakes happen.

• Math.ceil(x) rounds up toward positive infinity: ceil(4.1) is 5.0, ceil(-4.6) is -4.0. Returns a double.
• Math.floor(x) rounds down toward negative infinity: floor(4.9) is 4.0, floor(-4.5) is -5.0. Returns a double.
• Math.round(x) rounds to the nearest whole number, and a .5 tie goes up toward positive infinity: round(4.5) is 5 but round(-4.5) is -4. Returns a long for a double and an int for a float.
• Math.rint(x) rounds to the nearest whole number, but a .5 tie goes to the nearest even number: rint(4.5) is 4.0, rint(5.5) is 6.0. Returns a double.

Generating a Random Number in a Range

Math.random() alone only produces a double in [0.0, 1.0): 0.0 is possible, 1.0 never is. To generate a random integer within a specific range [min, max], the standard formula is (int) (Math.random() * (max - min + 1)) + min, so a dice roll is (int) (Math.random() * 6) + 1. The + 1 inside the brackets is what makes max reachable. For more advanced random number needs (seeding, other types, different distributions), the dedicated java.util.Random class, or ThreadLocalRandom.current().nextInt(min, max + 1), is generally preferred over Math.random().

Trigonometry and Logarithm Methods

• Math.sin, Math.cos and Math.tan expect the angle in radians, not degrees. Convert with Math.toRadians(30), and back with Math.toDegrees.
• Results are floating-point approximations: Math.sin(Math.toRadians(30)) prints 0.49999999999999994, not exactly 0.5.
• Math.log(x) is the natural logarithm (base e), Math.log10(x) is base 10, and Math.exp(x) is e raised to x.
• Math.signum(x) returns -1.0, 0.0 or 1.0 depending on the sign of x.
• Math.hypot(x, y) returns sqrt(x*x + y*y), the distance formula, without overflowing on large intermediate values.

Exact Methods for Overflow Handling

Ordinary int and long arithmetic overflows silently: Integer.MAX_VALUE + 1 becomes -2147483648 with no warning. The exact methods added in Java 8, such as Math.addExact, subtractExact, multiplyExact, incrementExact, negateExact and toIntExact, do the same calculation but throw ArithmeticException ("integer overflow") when the result does not fit. Use them for money, counters and IDs where a wrong number is worse than a crash. Related helpers Math.floorDiv and Math.floorMod round toward negative infinity, so floorMod(-7, 3) is 2 while -7 % 3 is -1.

Common Interview Questions

• Why can you not create a Math object? Its constructor is private and the class is final; all members are static.
• Do you need to import Math? No. It is in java.lang, which is imported automatically.
• What does Math.round(-4.5) return? -4, because ties round toward positive infinity.
• What is the return type of Math.round(double)? long. For a float argument it returns int.
• Difference between ceil(), floor() and round()? ceil rounds up, floor rounds down, round goes to the nearest whole number; ceil and floor return double, round returns long or int.
• How do you get a random int between 1 and 10? (int) (Math.random() * 10) + 1.
• What is Math.sqrt(-1)? NaN; no exception is thrown.
• How do you detect integer overflow? Use Math.addExact, multiplyExact and the other exact methods, which throw ArithmeticException.

Examples

public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.max(10, 25));
        System.out.println(Math.min(10, 25));
        System.out.println(Math.abs(-42));
        System.out.println(Math.pow(2, 10));
        System.out.println(Math.sqrt(64));
        System.out.println(Math.round(4.5));
        System.out.println(Math.floor(4.7));
        System.out.println(Math.ceil(4.1));
        System.out.println(Math.PI);
    }
}

25
10
42
1024.0
8.0
5
4.0
5.0
3.141592653589793

public class RoundingDemo {
    public static void main(String[] args) {
        double[] values = {4.5, 4.4, -4.5, -4.6, 5.5};

        for (double v : values) {
            System.out.println(v + " -> round " + Math.round(v)
                    + ", ceil " + Math.ceil(v)
                    + ", floor " + Math.floor(v)
                    + ", rint " + Math.rint(v));
        }

        System.out.println(Math.cbrt(27));
        System.out.println(Math.abs(Integer.MIN_VALUE));
    }
}

4.5 -> round 5, ceil 5.0, floor 4.0, rint 4.0
4.4 -> round 4, ceil 5.0, floor 4.0, rint 4.0
-4.5 -> round -4, ceil -4.0, floor -5.0, rint -4.0
-4.6 -> round -5, ceil -4.0, floor -5.0, rint -5.0
5.5 -> round 6, ceil 6.0, floor 5.0, rint 6.0
3.0
-2147483648

public class MathAdvancedDemo {
    public static void main(String[] args) {
        double angle = Math.toRadians(30);         // trig methods expect radians
        System.out.println(Math.sin(angle));
        System.out.println(Math.cos(Math.toRadians(60)));
        System.out.println(Math.toDegrees(Math.PI));

        System.out.println(Math.log(Math.E));      // natural log
        System.out.println(Math.log10(1000));
        System.out.println(Math.exp(0));

        System.out.println(Math.signum(-8.5));
        System.out.println(Math.hypot(3, 4));      // sqrt(3*3 + 4*4)
    }
}

0.49999999999999994
0.5000000000000001
180.0
1.0
3.0
1.0
-1.0
5.0

public class ExactDemo {
    public static void main(String[] args) {
        int big = Integer.MAX_VALUE;

        System.out.println(big + 1);               // silently wraps around

        try {
            System.out.println(Math.addExact(big, 1));
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        }

        try {
            System.out.println(Math.multiplyExact(100_000, 100_000));
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        }

        System.out.println(Math.multiplyExact(100_000L, 100_000L));
        System.out.println(Math.floorDiv(-7, 2) + " " + (-7 / 2));
        System.out.println(Math.floorMod(-7, 3) + " " + (-7 % 3));
    }
}

-2147483648
Caught: integer overflow
Caught: integer overflow
10000000000
-4 -3
2 -1

Exercise

Use Math methods to print the distance between the points (0, 0) and (3, 4), then 2 to the power of 10, then the absolute value of -7.

Expected output: 5.0, 1024.0, 7

public class MathPractice {

    static double distance(int x1, int y1, int x2, int y2) {
        // TODO: square root of (dx squared + dy squared)
        return 0;
    }

    public static void main(String[] args) {
        System.out.println(distance(0, 0, 3, 4));
        // TODO: print 2 to the power of 10
        // TODO: print the absolute value of -7
    }
}

public class MathPractice {

    static double distance(int x1, int y1, int x2, int y2) {
        int dx = x2 - x1;
        int dy = y2 - y1;
        return Math.sqrt(dx * dx + dy * dy);
    }

    public static void main(String[] args) {
        System.out.println(distance(0, 0, 3, 4)); // 5.0
        System.out.println(Math.pow(2, 10));      // 1024.0
        System.out.println(Math.abs(-7));         // 7
    }
}

Quick quiz

Interview questions