Java Métodos de Math

A classe Math é a calculadora científica do Java: potência, raiz, arredondamento, trigonometria e contas protegidas contra overflow. Todos os métodos são static: você escreve Math.sqrt(16), sem criar objeto nenhum, e não precisa de import (ela está em java.lang). A aula com a explicação passo a passo é Math.

Como ler as tabelas

Os resultados são reais, do JShell do JDK 25. 1024.0 é um double; 1024 sem ponto é um inteiro.
A maioria dos métodos aceita e devolve double. Os que têm versões para int/long (abs, max, min, floorDiv…) devolvem o mesmo tipo que receberam.
Números muito pequenos ou grandes aparecem em notação científica: 1.2246467991473532E-16 = 1,22 × 10^-16, praticamente zero.

Atalhos: Constantes · abs, max, min · Potências e raízes · Arredondar · Divisão inteira · Trigonometria · Contas exatas · Outros · StrictMath

Experimente: qualquer exemplo das tabelas funciona aqui. Calcule a hipotenusa de um triângulo de catetos 3 e 4 com Math.hypot(3, 4).

Math.hypot(3, 4)

Constantes

Método	O que faz	Exemplo	Resultado
`Math.PI`	π, a razão entre a circunferência e o diâmetro.	`Math.PI`	`3.141592653589793`
`Math.E`	O número de Euler, base do logaritmo natural.	`Math.E`	`2.718281828459045`
`Math.TAU` Java 19+	2π (uma volta inteira, em radianos).	`Math.TAU`	`6.283185307179586`

Valor absoluto, máximo, mínimo

Método	O que faz	Exemplo	Resultado
`abs(x)`	Valor absoluto (tira o sinal). Para `int`, `long`, `float` e `double`.	`Math.abs(-7)` `Math.abs(-2.5)`	`7` `2.5`
`max(a, b)`	O maior dos dois. Com tipos diferentes, o resultado é do tipo "maior" (`double` aqui).	`Math.max(3, 8)` `Math.max(2.5, 1)`	`8` `2.5`
`min(a, b)`	O menor dos dois.	`Math.min(3, 8)`	`3`
`signum(x)`	O sinal: -1.0, 0.0 ou 1.0.	`Math.signum(-4.2)` `Math.signum(0.0)`	`-1.0` `0.0`
`clamp(valor, mín, máx)` Java 21+	"Prende" o valor no intervalo: abaixo do mínimo vira o mínimo, acima do máximo vira o máximo.	`Math.clamp(15, 0, 10)` `Math.clamp(-3, 0, 10)`	`10` `0`

Potências, raízes e logaritmos

Método	O que faz	Exemplo	Resultado
`pow(base, expoente)`	Potência. Sempre devolve `double`.	`Math.pow(2, 10)` `Math.pow(9, 0.5)`	`1024.0` `3.0`
`sqrt(x)`	Raiz quadrada. De número negativo: `NaN` (não é um número).	`Math.sqrt(16)` `Math.sqrt(2)` `Math.sqrt(-1)`	`4.0` `1.4142135623730951` `NaN`
`cbrt(x)`	Raiz cúbica.	`Math.cbrt(27)`	`3.0`
`hypot(x, y)`	Hipotenusa: √(x² + y²), sem estourar com números grandes.	`Math.hypot(3, 4)`	`5.0`
`exp(x)`	e elevado a x.	`Math.exp(1)`	`2.718281828459045`
`log(x)`	Logaritmo natural (base e).	`Math.log(Math.E)`	`1.0`
`log10(x)`	Logaritmo na base 10.	`Math.log10(1000)`	`3.0`

Arredondar

Método	O que faz	Exemplo	Resultado
`round(x)`	Arredonda para o inteiro mais próximo; o meio (.5) sobe em direção ao +∞. De `double` devolve `long`; de `float`, `int`.	`Math.round(2.5)` `Math.round(-2.5)` `Math.round(2.4f)`	`3` `-2` `2`
`rint(x)`	Inteiro mais próximo como `double`; o meio vai para o par ("arredondamento do banqueiro").	`Math.rint(2.5)` `Math.rint(3.5)`	`2.0` `4.0`
`floor(x)`	Piso: o inteiro de baixo (em direção ao −∞).	`Math.floor(2.7)` `Math.floor(-2.3)`	`2.0` `-3.0`
`ceil(x)`	Teto: o inteiro de cima (em direção ao +∞).	`Math.ceil(2.1)` `Math.ceil(-2.7)`	`3.0` `-2.0`
`round(x * 100) / 100.0`	Truque para 2 casas decimais (para mostrar na tela, prefira `printf("%.2f")`; para dinheiro, `BigDecimal`).	`Math.round(1234.5678 * 100) / 100.0`	`1234.57`

Divisão inteira

Método	O que faz	Exemplo	Resultado
`floorDiv(a, b)`	Divisão inteira arredondando para baixo. Difere do `/` com números negativos.	`Math.floorDiv(-7, 2)` `-7 / 2`	`-4` `-3`
`floorMod(a, b)`	Resto com o sinal do divisor (sempre positivo se `b` for positivo). O `%` usa o sinal do dividendo.	`Math.floorMod(-7, 3)` `-7 % 3`	`2` `-1`

Trigonometria (ângulos em radianos)

Método	O que faz	Exemplo	Resultado
`sin(x), cos(x), tan(x)`	Seno, cosseno e tangente. O `double` tem erros minúsculos: sen(π) não dá 0 exato.	`Math.sin(Math.PI / 2)` `Math.sin(Math.PI)` `Math.cos(0)` `Math.tan(Math.PI / 4)`	`1.0` `1.2246467991473532E-16` `1.0` `0.9999999999999999`
`asin(x), acos(x), atan(x)`	Funções inversas: devolvem o ângulo.	`Math.asin(1)`	`1.5707963267948966`
`atan2(y, x)`	O ângulo do ponto (x, y), entre −π e π.	`Math.atan2(1, 1)`	`0.7853981633974483`
`toRadians(graus)`	Graus para radianos.	`Math.toRadians(180)`	`3.141592653589793`
`toDegrees(radianos)`	Radianos para graus.	`Math.toDegrees(Math.PI)`	`180.0`

Contas exatas (sem overflow silencioso)

Método	O que faz	Exemplo	Resultado
`addExact(a, b)` Java 8+	Soma que lança `ArithmeticException` se passar do limite do tipo, em vez de "dar a volta".	`Math.addExact(2_000_000_000, 2_000_000_000)` `2_000_000_000 + 2_000_000_000`	`ArithmeticException: integer overflow` `-294967296`
`multiplyExact(a, b)` Java 8+	Multiplicação com a mesma proteção.	`Math.multiplyExact(100_000, 100_000)`	`ArithmeticException: integer overflow`
`toIntExact(long)` Java 8+	Converte `long` em `int`, ou lança a exceção se não couber.	`Math.toIntExact(3_000_000_000L)`	`ArithmeticException: integer overflow`
`negateExact(x), absExact(x)`	Troca o sinal / valor absoluto com proteção (o `absExact` é do Java 15).	`Math.negateExact(5)` `Math.absExact(-5)`	`-5` `5`
`abs(Integer.MIN_VALUE)`	A pegadinha que o `absExact` resolve: o menor `int` não tem positivo correspondente.	`Math.abs(Integer.MIN_VALUE)`	`-2147483648`

Outros

Método	O que faz	Exemplo	Resultado
`random()`	Um `double` aleatório em [0.0, 1.0). Para inteiros, prefira `Random` (veja Números Aleatórios).	`Math.random() < 1.0`	`true`
`fma(a, b, c)` Java 9+	a × b + c com um único arredondamento (mais preciso).	`Math.fma(2.0, 3.0, 1.0)`	`7.0`
`ulp(x)`	A distância até o próximo `double`: o tamanho do "degrau" naquele número.	`Math.ulp(1.0)`	`2.220446049250313E-16`
`nextUp(x)`	O próximo `double` depois de x.	`Math.nextUp(1.0)`	`1.0000000000000002`
`copySign(valor, sinal)`	O valor com o sinal do segundo argumento.	`Math.copySign(3.0, -1.0)`	`-3.0`

`StrictMath`: o mesmo resultado em qualquer máquina

StrictMath tem os mesmos métodos que Math, com uma promessa extra: o resultado é idêntico, bit a bit, em qualquer computador, porque segue um algoritmo de referência fixo (a biblioteca fdlibm). O Math pode usar instruções especiais do processador, mais rápidas, que às vezes diferem na última casa decimal (dentro do erro permitido pela documentação).

$ jshell
|  Welcome to JShell -- Version 25.0.4.1
|  For an introduction type: /help intro

jshell> StrictMath.sqrt(2)
$1 ==> 1.4142135623730951

jshell> StrictMath.pow(2, 10)
$2 ==> 1024.0

Use	Quando
`Math`	Quase sempre. É o padrão, e o mais rápido.
`StrictMath`	Quando o mesmo cálculo precisa dar o mesmo resultado em máquinas diferentes: simulações científicas reproduzíveis, testes que comparam números com todas as casas.
`BigDecimal`	Dinheiro e qualquer conta decimal que precise ser exata (veja BigDecimal e Dinheiro).

A palavra-chave strictfp, que fazia algo parecido para as contas comuns (+, *…), não tem mais efeito desde o Java 17: todas as contas de ponto flutuante já são estritas (veja Palavras-chave).

Armadilhas

Math.round de double devolve long

Este código tem um erro de propósito.

        int arredondado = Math.round(2.5);

$ java Main.java
Main.java:3: error: incompatible types: possible lossy conversion from long to int
        int arredondado = Math.round(2.5);
                                    ^
1 error
error: compilation failed

"Tipos incompatíveis: possível perda na conversão de long para int." Guarde num long, ou converta explicitamente: int arredondado = (int) Math.round(2.5); (veja Conversão de Tipos).

Arredondar para mostrar × arredondar para guardar

        double raio = 2.5;
        double area = Math.PI * Math.pow(raio, 2);
        System.out.println("Área: " + area);
        System.out.println("Área: " + Math.round(area * 100) / 100.0);
        System.out.printf("Área: %.2f%n", area);

$ java Main.java
Área: 19.634954084936208
Área: 19.63
Área: 19,63                       « printf usa o idioma do sistema: vírgula em pt_BR

Para mostrar, use printf ou String.format (o número guardado continua com todas as casas). O truque do round(x * 100) / 100.0 muda o valor guardado, mas o resultado ainda é um double, com os mesmos pequenos erros de sempre. Para dinheiro, BigDecimal.

Overflow silencioso

Na tabela Contas exatas: 2_000_000_000 + 2_000_000_000 dá -294967296, sem erro nenhum. O resultado não cabe num int e "dá a volta". Quando isso importa (quantidades, contadores, dinheiro em centavos), use Math.addExact/multiplyExact, que lançam ArithmeticException: integer overflow, ou long (veja int, long, short, byte).

Missão: para o círculo de raio 2.5, mostre a área (π r²) e o perímetro (2 π r) arredondados para 2 casas com Math.round(x * 100) / 100.0: Área: 19.63 e Perímetro: 15.71.

public class Main {
    public static void main(String[] args) {
        double raio = 2.5;
        // calcule a área e o perímetro com Math.PI e arredonde para 2 casas
    }
}

public class Main {
    public static void main(String[] args) {
        double raio = 2.5;
        double area = Math.PI * Math.pow(raio, 2);
        double perimetro = 2 * Math.PI * raio;
        System.out.println("Área: " + Math.round(area * 100) / 100.0);
        System.out.println("Perímetro: " + Math.round(perimetro * 100) / 100.0);
    }
}

Exercícios

1. Quanto vale Math.round(-2.5)?

-3 -2.5 -2 3

2. Qual a diferença entre -7 / 2 e Math.floorDiv(-7, 2)?

/ dá -3 (corta para o zero); floorDiv dá -4 (arredonda para baixo). Nenhuma. / dá -3.5. floorDiv lança exceção com negativos.

3. Que tipo Math.pow(2, 10) devolve?

int long float double (1024.0)

Complete para limitar a nota entre 0 e 10 (Java 21+):

int nota = Math.(valor, 0, 10);

Resumo

Math é toda static, sem import: Math.metodo(…).
Potência e raiz (pow, sqrt) devolvem double; round de double devolve long.
floor/ceil/round/rint arredondam de jeitos diferentes; com negativos, confira.
floorDiv/floorMod diferem de / e % com negativos; addExact e cia. avisam o overflow.
StrictMath: mesmos métodos, resultado idêntico em qualquer máquina.