Classe Java Math

La classe java.lang.Math est un ensemble de méthodes statiques pour les opérations mathématiques qui vont au-delà des opérateurs de base +, -, *, /, %. Valeurs absolues, puissances, racines, trigonométrie, logarithmes, arrondis et nombres aléatoires s'y trouvent tous. Comme Math appartient au package java.lang, elle est implicitement importée — vous n'écrivez jamais d'instruction import, vous appelez directement les méthodes : Math.sqrt(2).

Cette page présente chaque groupe de méthodes, indique la valeur exacte retournée et signale les pièges (quelles méthodes retournent double ou long, pourquoi la trigonométrie fonctionne en radians, et quand Math n'est pas le bon outil). Chaque méthode est static, vous l'appelez donc sur la classe elle-même, jamais sur une instance.

Valeur absolue, min, max

Math.abs(-7);          // 7
Math.abs(-3.14);       // 3.14

Math.min(3, 5);        // 3
Math.max(3, 5);        // 5
Math.min(1.5, 1.7);    // 1.5

Les quatre sont surchargées pour int, long, float et double.

Puissances et racines

Math.pow(2, 10);       // 1024.0  — always returns double
Math.sqrt(2);          // 1.4142135623730951
Math.cbrt(27);         // 3.0
Math.exp(1);           // 2.718281828... — e^x

Pour les exposants entiers, Math.pow est excessif — une boucle ou << est plus rapide.

Logarithmes

Math.log(Math.E);      // 1.0  — natural log (ln)
Math.log10(1000);      // 3.0  — base-10 log
Math.log(8) / Math.log(2);   // 3.0 — log base 2

Java ne possède pas de méthode « log base N » intégrée, vous devez donc la calculer avec la règle du changement de base : Math.log(x) / Math.log(base). Pour une précision accrue près de x = 1, Math.log1p(x) calcule ln(1 + x) et Math.expm1(x) calcule e^x - 1 sans perdre de chiffres significatifs.

Arrondis

Math.floor(2.7);       // 2.0
Math.ceil(2.1);        // 3.0
Math.round(2.5);       // 3   — ties round up
Math.round(-2.5);      // -2  — toward positive infinity
Math.rint(0.5);        // 0.0 — banker's rounding
Math.rint(1.5);        // 2.0

Pour un arrondi tenant compte des décimales (par exemple, à deux décimales pour les montants), utilisez BigDecimal avec un RoundingMode.

Trigonométrie

Toutes les fonctions trigonométriques travaillent en radians. Convertissez avec Math.toRadians / Math.toDegrees :

Math.sin(Math.PI / 2);          // 1.0
Math.cos(0);                    // 1.0
Math.tan(Math.PI / 4);          // 0.999999... (≈ 1)

Math.toRadians(180);            // Math.PI
Math.toDegrees(Math.PI);        // 180.0

Math.atan2(1, 1);               // π/4  — handles quadrant correctly

Math.atan2(y, x) est le bon outil pour « quel est l'angle de ce vecteur », et non Math.atan(y/x).

Constantes

Math.PI;       // 3.141592653589793
Math.E;        // 2.718281828459045

Nombres aléatoires

Math.random() retourne un double uniformément distribué dans [0.0, 1.0) :

double r = Math.random();          // 0.0 ≤ r < 1.0
int dieRoll = 1 + (int)(Math.random() * 6);  // 1..6

Pour tout usage plus avancé (valeur initiale, résultats reproductibles, plages, gaussiennes), utilisez java.util.Random ou java.util.concurrent.ThreadLocalRandom :

import java.util.Random;
Random rng = new Random(42);   // seeded, reproducible
int n = rng.nextInt(100);      // 0..99
double g = rng.nextGaussian(); // normal distribution

Pour les jetons de sécurité, n'utilisez pas Math.random ni Random — utilisez java.security.SecureRandom.

Arithmétique avec vérification de dépassement

Math.addExact, subtractExact, multiplyExact, negateExact, incrementExact, decrementExact lèvent une ArithmeticException en cas de dépassement d'entier :

Math.addExact(Integer.MAX_VALUE, 1);  // throws ArithmeticException

Utile lorsque la correction du résultat prime sur la vitesse.

Une démonstration

Ce qui suit

• Opérateurs Java — l'arithmétique +, -, *, /, % sur laquelle Math s'appuie.
• Types de données Java — pourquoi Math.pow retourne double et quand un int déborde.
• Saisie utilisateur Java avec Scanner — lire des nombres et du texte depuis le terminal.

Pratique