Classe Math do Java

A classe java.lang.Math é uma coleção de métodos estáticos para operações matemáticas que vão além dos operadores básicos +, -, *, /, %. Valores absolutos, potências, raízes, trigonometria, logaritmos, arredondamento e números aleatórios estão todos aqui. Como Math pertence ao pacote java.lang, ele é importado implicitamente — você nunca escreve uma instrução import, basta chamar os métodos diretamente: Math.sqrt(2).

Esta página percorre cada grupo de métodos, mostra o valor exato que eles retornam e destaca as armadilhas (quais métodos retornam double vs long, por que a trigonometria trabalha em radianos e quando Math não é a ferramenta certa). Todos os métodos são static, portanto você os chama na própria classe, nunca em uma instância.

Valor absoluto, mín, máx

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

Os quatro métodos são sobrecarregados para int, long, float e double.

Potências e raízes

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 expoentes inteiros, Math.pow é excessivo — um loop ou << é mais 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 não possui um método nativo de "log base N", portanto você o calcula com a regra da mudança de base: Math.log(x) / Math.log(base). Para maior precisão próximo a x = 1, Math.log1p(x) calcula ln(1 + x) e Math.expm1(x) calcula e^x - 1 sem perder dígitos significativos.

Arredondamento

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 arredondamento com consciência de casas decimais (por exemplo, duas casas para valores monetários), use BigDecimal com um RoundingMode.

Trigonometria

Todas as funções trigonométricas trabalham em radianos. Converta com 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) é a ferramenta certa para "qual é o ângulo deste vetor", não Math.atan(y/x).

Constantes

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

Números aleatórios

Math.random() retorna um double uniformemente distribuído em [0.0, 1.0):

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

Para necessidades mais avançadas (com semente, repetível, intervalos, gaussianas), use 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

Para tokens de segurança, não use Math.random ou Random — use java.security.SecureRandom.

Aritmética com verificação de overflow

Math.addExact, subtractExact, multiplyExact, negateExact, incrementExact, decrementExact lançam ArithmeticException em caso de overflow de inteiro:

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

Útil quando a correção importa mais do que a velocidade.

Uma demonstração

O que vem a seguir

• Operadores Java — a aritmética +, -, *, /, % sobre a qual Math se baseia.
• Tipos de Dados Java — por que Math.pow retorna double e quando um int sofre overflow.
• Entrada do Usuário Java com Scanner — leitura de números e texto pelo terminal.

Prática