Clase Math de Java

La clase java.lang.Math es una colección de métodos estáticos para las operaciones matemáticas que van más allá de los operadores básicos +, -, *, /, %. Valores absolutos, potencias, raíces, trigonometría, logaritmos, redondeo y números aleatorios se encuentran aquí. Como Math está en el paquete java.lang, se importa implícitamente — nunca escribes una sentencia import, simplemente llamas los métodos directamente: Math.sqrt(2).

Esta página recorre cada grupo de métodos, muestra el valor exacto que devuelven y señala los puntos a tener en cuenta (qué métodos devuelven double vs long, por qué la trigonometría trabaja en radianes y cuándo Math no es la herramienta adecuada). Todos los métodos son static, por lo que se llaman sobre la clase misma, nunca sobre una instancia.

Valor absoluto, mínimo, máximo

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

Los cuatro están sobrecargados para int, long, float y double.

Potencias y raíces

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

Para exponentes enteros, Math.pow es excesivo — un bucle o << es más rápido.

Logaritmos

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 no tiene un método "log base N" incorporado, por lo que se calcula con la regla de cambio de base: Math.log(x) / Math.log(base). Para mayor precisión cerca de x = 1, Math.log1p(x) calcula ln(1 + x) y Math.expm1(x) calcula e^x - 1 sin perder dígitos significativos.

Redondeo

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

Para redondeo con conciencia decimal (p. ej., a dos decimales para dinero), usa BigDecimal con un RoundingMode.

Trigonometría

Todas las funciones trigonométricas trabajan en radianes. Convierte 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) es la herramienta correcta para "¿cuál es el ángulo de este vector?", no Math.atan(y/x).

Constantes

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

Números aleatorios

Math.random() devuelve un double uniformemente distribuido en [0.0, 1.0):

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

Para algo más (semillado, repetible, rangos, gaussianas), usa 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

Para tokens de seguridad, no uses Math.random ni Random — usa java.security.SecureRandom.

Aritmética con comprobación de desbordamiento

Math.addExact, subtractExact, multiplyExact, negateExact, incrementExact, decrementExact lanzan ArithmeticException ante desbordamiento de enteros:

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

Útil cuando la corrección importa más que la velocidad.

Una demostración

Qué sigue

• Operadores de Java — la aritmética +, -, *, /, % sobre la que se construye Math.
• Tipos de datos de Java — por qué Math.pow devuelve double y cuándo un int desborda.
• Entrada de usuario en Java con Scanner — lectura de números y texto desde la terminal.

Práctica