Classe Math in Java

La classe java.lang.Math è una raccolta di metodi statici per operazioni matematiche che vanno oltre i operatori di base +, -, *, /, %. Valori assoluti, potenze, radici, trigonometria, logaritmi, arrotondamento e numeri casuali si trovano tutti qui. Poiché Math si trova nel pacchetto java.lang, viene importata implicitamente — non è mai necessario scrivere un'istruzione import, basta chiamare i metodi direttamente: Math.sqrt(2).

Questa pagina illustra ogni gruppo di metodi, mostra il valore esatto restituito e indica le insidie (quali metodi restituiscono double vs long, perché la trigonometria lavora in radianti e quando Math non è lo strumento giusto). Ogni metodo è static, quindi lo si chiama sulla classe stessa, mai su un'istanza.

Valore assoluto, 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

Tutti e quattro sono sovraccaricati per int, long, float e double.

Potenze e radici

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

Per esponenti interi, Math.pow è eccessivo — un ciclo o << è più veloce.

Logaritmi

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 non ha un metodo incorporato "log in base N", quindi lo si calcola con la regola del cambiamento di base: Math.log(x) / Math.log(base). Per una precisione più elevata vicino a x = 1, Math.log1p(x) calcola ln(1 + x) e Math.expm1(x) calcola e^x - 1 senza perdere cifre significative.

Arrotondamento

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

Per l'arrotondamento con consapevolezza dei decimali (ad esempio a due cifre decimali per valori monetari), usare BigDecimal con un RoundingMode.

Trigonometria

Tutte le funzioni trigonometriche lavorano in radianti. Convertire con 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) è lo strumento giusto per "qual è l'angolo di questo vettore", non Math.atan(y/x).

Costanti

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

Numeri casuali

Math.random() restituisce un double uniformemente distribuito in [0.0, 1.0):

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

Per qualsiasi altra esigenza (con seed, ripetibile, intervalli, gaussiane), usare java.util.Random o 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

Per token di sicurezza, non usare Math.random o Random — usare java.security.SecureRandom.

Aritmetica con controllo dell'overflow

Math.addExact, subtractExact, multiplyExact, negateExact, incrementExact, decrementExact lanciano ArithmeticException in caso di overflow intero:

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

Utile quando la correttezza è più importante della velocità.

Una dimostrazione

Cosa c'è dopo

• Operatori Java — l'aritmetica con +, -, *, /, % su cui si basa Math.
• Tipi di dati Java — perché Math.pow restituisce double e quando un int va in overflow.
• Input utente Java con Scanner — leggere numeri e testo dal terminale.

Esercitazione