Classe Math em Java: pow, sqrt, abs, round, random e mais

Uma caixa de ferramentas de métodos estáticos

java.lang.Math é uma classe cheia de funções matemáticas prontas: potências, raízes, valor absoluto, arredondamento, trigonometria, logaritmos e números aleatórios. Duas coisas a tornam fácil de usar:

• Ela fica em java.lang, que todo arquivo Java importa automaticamente. Não há linha de import para escrever.
• Todo método é static. Você o chama pelo nome da classe, Math.sqrt(25), e nunca cria um objeto Math. A página de membros estáticos explica o que static significa.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(2, 3));    // 8.0
        System.out.println(Math.sqrt(25));     // 5.0
        System.out.println(Math.abs(-7));      // 7
        System.out.println(Math.max(4, 9));    // 9
        System.out.println(Math.round(2.6));   // 3
    }
}

Repare que alguns resultados aparecem com .0 e outros não. Cada método de Math tem um tipo de retorno fixo, e conhecer esse tipo é quase tudo o que há para aprender sobre esta classe.

Math.pow: potências

Math.pow(base, exponent) eleva um número a uma potência. Recebe dois parâmetros double e retorna um double, mesmo quando você passa números inteiros:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(2, 3));     // 8.0
        System.out.println(Math.pow(5, 2));     // 25.0
        System.out.println(Math.pow(2, -1));    // 0.5
        System.out.println(Math.pow(9, 0.5));   // 3.0 (uma raiz quadrada)

        int kilobyte = (int) Math.pow(2, 10);
        System.out.println(kilobyte);           // 1024
    }
}

Para guardar o resultado num int, faça um cast com (int). Para potências inteiras pequenas o resultado double é exato, então o cast dá a resposta certa. É com resultados grandes que o cast dá errado: um double acima de Integer.MAX_VALUE (2.147.483.647) vira exatamente Integer.MAX_VALUE, então (int) Math.pow(2, 40) dá 2147483647. Faça o cast para long em potências maiores, e lembre que acima de 2⁵³ um double não consegue representar todo número inteiro com exatidão. A página de conversão de tipos explica o que um cast faz com o valor.

Java não tem operador de potência. 2 ^ 3 compila, mas ^ é o XOR bit a bit, e o resultado é 1, não 8. Esse é um dos bugs mais comuns de iniciantes em código matemático Java.

Um double de dez milhões ou mais é impresso em notação científica, o que surpreende na primeira vez que você imprime uma potência de dez:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(10, 6));          // 1000000.0
        System.out.println(Math.pow(10, 7));          // 1.0E7
        System.out.println((long) Math.pow(10, 7));   // 10000000
    }
}

1.0E7 significa 1,0 × 10⁷. O valor é o mesmo; só a forma impressa muda. Faça o cast para long, ou formate com String.format("%.0f", value), para imprimir só os dígitos.

Math.sqrt e Math.cbrt: raízes

Math.sqrt(x) retorna a raiz quadrada de x como double. Math.cbrt(x) retorna a raiz cúbica.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.sqrt(16));    // 4.0
        System.out.println(Math.sqrt(2));     // 1.4142135623730951
        System.out.println(Math.cbrt(27));    // 3.0
        System.out.println(Math.sqrt(-4));    // NaN

        double a = 3;
        double b = 4;
        System.out.println(Math.sqrt(a * a + b * b));   // 5.0
        System.out.println(Math.hypot(a, b));           // 5.0
    }
}

A raiz quadrada de um número negativo não é um número real, então Math.sqrt(-4) retorna NaN ("not a number", não é um número) em vez de lançar uma exceção. NaN se espalha por qualquer conta em que aparece, então verifique as entradas antes de tirar uma raiz se valores negativos forem possíveis. Math.hypot(a, b) calcula sqrt(a*a + b*b) diretamente, um jeito comum de obter a distância entre dois pontos.

Math.abs: valor absoluto

Math.abs(x) remove o sinal. Ao contrário de pow e sqrt, retorna o mesmo tipo que você passa: um int para um int, um double para um double.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.abs(-7));      // 7
        System.out.println(Math.abs(7));       // 7
        System.out.println(Math.abs(-2.5));    // 2.5

        int start = 12;
        int end = 5;
        System.out.println("Distance: " + Math.abs(end - start));   // Distance: 7
    }
}

O uso típico é uma diferença em que importa o tamanho, não a direção, como a distância entre duas posições.

Math.max e Math.min

Math.max(a, b) retorna o maior de dois valores e Math.min(a, b) o menor. Recebem exatamente dois argumentos. Para três ou mais, aninhe as chamadas:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.max(4, 9));      // 9
        System.out.println(Math.min(4, 9));      // 4
        System.out.println(Math.max(3, 7.5));    // 7.5

        int a = 12, b = 45, c = 30;
        System.out.println(Math.max(a, Math.max(b, c)));   // 45

        int score = 130;
        int clamped = Math.max(0, Math.min(score, 100));
        System.out.println(clamped);             // 100
    }
}

Quando os dois argumentos têm tipos diferentes, o mais estreito é alargado primeiro. Math.max(3, 7.5) compara dois valores double e retorna um double. O último exemplo limita um valor ao intervalo de 0 a 100: Math.min o limita a 100, e Math.max impede que fique abaixo de 0.

Arredondamento: round, floor, ceil

Java tem três métodos de arredondamento, e eles diferem tanto na direção quanto no tipo de retorno:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.round(2.4));    // 2
        System.out.println(Math.round(2.5));    // 3
        System.out.println(Math.round(-2.5));   // -2

        System.out.println(Math.floor(2.7));    // 2.0
        System.out.println(Math.floor(-2.3));   // -3.0

        System.out.println(Math.ceil(2.1));     // 3.0
        System.out.println(Math.ceil(-2.7));    // -2.0

        System.out.println((int) 2.7);          // 2
        System.out.println((int) -2.7);         // -2
    }
}

• Math.round vai para o inteiro mais próximo. Um valor exatamente na metade arredonda para cima, na direção do infinito positivo, então 2.5 vira 3 e -2.5 vira -2. Retorna um long para um argumento double (e um int para um float).
• Math.floor sempre arredonda para baixo, na direção do infinito negativo, e retorna um double.
• Math.ceil sempre arredonda para cima, na direção do infinito positivo, e retorna um double.
• Um cast (int) não é arredondamento: ele descarta a parte fracionária, o que leva números positivos para baixo e negativos para cima.

Como Math.round(double) retorna um long, atribuí-lo a um int não compila sem um cast:

int n = Math.round(2.6);          // error: incompatible types: possible lossy conversion from long to int
int m = (int) Math.round(2.6);    // OK, m vale 3
long k = Math.round(2.6);         // OK

Para arredondar para um número de casas decimais, multiplique, arredonde e divida de volta. Dividir por 100.0 (um double) em vez de 100 mantém as casas decimais:

public class Main {
    public static void main(String[] args) {
        double price = 19.4567;

        System.out.println(Math.round(price * 100) / 100.0);   // 19.46
        System.out.println(Math.round(price * 100) / 100);     // 19

        System.out.println(String.format("%.2f", price));      // 19.46
    }
}

A segunda linha divide um long por um int, o que é divisão inteira, então as casas decimais se perdem. Quando você só precisa mostrar um número arredondado, String.format("%.2f", value) é mais simples e não altera o valor guardado.

Math.random: números aleatórios

Math.random() retorna um double maior ou igual a 0.0 e menor que 1.0. O valor muda a cada chamada, então a saída dos programas desta seção muda toda vez que você aperta Run.

public class Main {
    public static void main(String[] args) {
        double r = Math.random();
        System.out.println(r);
        System.out.println(r >= 0.0 && r < 1.0);   // true
    }
}

Para obter um número inteiro num intervalo, estique esse valor, faça o cast e desloque. Para um inteiro de min a max, os dois incluídos:

int value = (int) (Math.random() * (max - min + 1)) + min;

Veja como isso funciona para um dado, em que min é 1 e max é 6:

1. Math.random() * 6 dá um double de 0.0 até 6.0, sem incluir o 6.0.
2. (int) descarta a fração, dando um de 0, 1, 2, 3, 4, 5.
3. + 1 desloca isso para 1, 2, 3, 4, 5, 6.

public class Main {
    public static void main(String[] args) {
        int min = 1;
        int max = 6;

        for (int i = 0; i < 5; i++) {
            int roll = (int) (Math.random() * (max - min + 1)) + min;
            System.out.print(roll + " ");
        }
        System.out.println();

        int lowest = max;
        int highest = min;
        for (int i = 0; i < 10000; i++) {
            int roll = (int) (Math.random() * (max - min + 1)) + min;
            lowest = Math.min(lowest, roll);
            highest = Math.max(highest, roll);
        }
        System.out.println("lowest: " + lowest + ", highest: " + highest);
    }
}

A primeira linha mostra cinco lançamentos aleatórios. A segunda verifica dez mil lançamentos e, na prática, sempre imprime lowest: 1, highest: 6: a fórmula alcança as duas pontas do intervalo e nunca passa delas.

Os parênteses em volta de Math.random() * (max - min + 1) importam. Um cast se aplica ao valor logo depois dele, então (int) Math.random() * 6 converte Math.random() primeiro. Isso é sempre 0, e 0 * 6 é 0, então todo "lançamento" sai igual.

Math.random() serve bem para jogos e exercícios. Para algo além disso, a classe java.util.Random e ThreadLocalRandom.current().nextInt(min, max + 1) (em java.util.concurrent) retornam inteiros diretamente, e Random aceita uma semente (seed) para repetir a mesma sequência em testes. Nenhum deles serve para senhas ou tokens de segurança; para isso, use java.security.SecureRandom.

Math.PI e Math.E

Math.PI (π) e Math.E (o número de Euler, e) são constantes static final double:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.PI);   // 3.141592653589793
        System.out.println(Math.E);    // 2.718281828459045

        double radius = 3;
        double area = Math.PI * radius * radius;
        double circumference = 2 * Math.PI * radius;

        System.out.printf("area: %.2f%n", area);                     // area: 28.27
        System.out.printf("circumference: %.2f%n", circumference);   // circumference: 18.85
    }
}

Use essas constantes em vez de digitar 3.14. Elas são tão precisas quanto um double permite, e o nome diz a quem lê que número é aquele.

Resultados inteiros contra resultados double

A maioria dos métodos de Math recebe e retorna double. Quando você passa valores int, o Java alarga os argumentos para double automaticamente, mas a conta que você escreve antes da chamada ainda acontece em int. É daí que vem a maioria das respostas erradas:

public class Main {
    public static void main(String[] args) {
        int items = 7;
        int perBox = 2;

        System.out.println(Math.ceil(items / perBox));            // 3.0 (errado)
        System.out.println(Math.ceil((double) items / perBox));   // 4.0

        System.out.println(Math.sqrt(10 / 4));     // 1.4142135623730951
        System.out.println(Math.sqrt(10 / 4.0));   // 1.5811388300841898

        int boxes = (int) Math.ceil((double) items / perBox);
        System.out.println(boxes + " boxes");      // 4 boxes
    }
}

items / perBox é 7 / 2, e dividir dois valores int descarta o resto, então o resultado é 3 antes mesmo de Math.ceil vê-lo. Math.ceil(3.0) é 3.0. Faça um dos operandos ser double, com um cast ou um literal como 4.0, para a divisão manter a fração. A página de operadores explica a divisão inteira com mais detalhes.

A regra geral: decida qual tipo você quer no final, faça a divisão ou a multiplicação acontecer em double quando as frações importam, e converta de volta para int ou long uma única vez, no final.

Outros métodos úteis

Mais alguns métodos da mesma classe, todos chamados do mesmo jeito:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.log10(1000));      // 3.0
        System.out.println(Math.log(Math.E));      // 1.0 (logaritmo natural)
        System.out.println(Math.signum(-4.2));     // -1.0

        System.out.println(-7 % 3);                // -1
        System.out.println(Math.floorMod(-7, 3));  // 2

        double angle = Math.toRadians(90);
        System.out.println(Math.sin(angle));       // 1.0

        try {
            Math.addExact(Integer.MAX_VALUE, 1);
        } catch (ArithmeticException e) {
            System.out.println("overflow: " + e.getMessage());   // overflow: integer overflow
        }
    }
}

• Math.log é o logaritmo natural; Math.log10 é na base 10.
• Math.floorMod(a, b) dá um resto com o sinal de b, que é o que você quer para dar a volta num intervalo como os dias da semana. O operador % mantém o sinal de a.
• Os métodos de trigonometria (sin, cos, tan) recebem radianos. Converta graus com Math.toRadians antes.
• Math.addExact, Math.multiplyExact e seus parentes lançam uma ArithmeticException em caso de overflow, em vez de dar a volta em silêncio para um número negativo.