La clase `Math` en Java

🧮 La clase `Math` en Java

En este tutorial vamos a ver la clase Math para realizar operaciones matemáticas.

Math está en el paquete java.lang, así que siempre está disponible
(no necesitamos importarla).

📌 Se usa así:

Math.algo(...)

🔁 `Math.round()` (redondear)

round redondea al entero más cercano.

✅ Está sobrecargado (existe en dos versiones):

Math.round(float) → devuelve int
Math.round(double) → devuelve long

public class Type1 {
    public static void main(String[] args) {
        int resultado = Math.round(1.1f);
        System.out.println(resultado); // 1
    }
}

📌 Por eso ponemos f: para que sea float y use la versión que devuelve int.

⬆️ `Math.ceil()` (techo)

ceil devuelve el entero más pequeño que es mayor o igual al número.

Ejemplo: ceil(1.1) = 2

⚠️ Ojo: ceil devuelve double, por eso esto da error:

int resultado = Math.ceil(1.1); // ❌ devuelve double

✅ Solución: casting explícito

public class Type1 {
    public static void main(String[] args) {
        int resultado = (int) Math.ceil(1.1);
        System.out.println(resultado); // 2
    }
}

⬇️ `Math.floor()` (piso)

floor devuelve el entero más grande que es menor o igual al número.

Ejemplo: floor(1.1) = 1

public class Type1 {
    public static void main(String[] args) {
        int resultado = (int) Math.floor(1.1);
        System.out.println(resultado); // 1
    }
}

🏁 `Math.max()` y `Math.min()`

max(a, b) devuelve el mayor, min(a, b) el menor.

public class Type1 {
    public static void main(String[] args) {
        int resultado = Math.max(3, 5);
        System.out.println(resultado); // 5
    }
}

📌 También están sobrecargados (hay versiones para int, long, float, double).

🎲 `Math.random()`

random() genera un double entre 0.0 y 1.0.

⚠️ Por eso esto da error (porque devuelve double):

🎲 `Math.random()`

int r = Math.random(); // ❌

🎲 `Math.random()`

public class Type1 {
    public static void main(String[] args) {
        double r = Math.random();
        System.out.println(r);
    }
}

✅ Correcto

🎯 Aleatorio entre 0 y 100

Solo multiplicamos:

public class Type1 {
    public static void main(String[] args) {
        double r = Math.random() * 100;
        System.out.println(r);
    }
}

✅ Sale un número diferente cada vez, entre 0.0 y 100.0

✅ Aleatorio entero entre 0 y 100

Si queremos quitar los decimales, podemos redondear:

public class Type1 {
    public static void main(String[] args) {
        long r = Math.round(Math.random() * 100);
        System.out.println(r);
    }
}

📌 Ojo: aquí round(...) devuelve long porque la expresión es double.

⚠️ ¿Y si lo quiero en `int`?

Esto da error:

int r = Math.round(Math.random() * 100); // ❌ devuelve long

✅ Solución: casting explícito (en este caso es seguro porque está entre 0 y 100)

public class Type1 {
    public static void main(String[] args) {
        int r = (int) Math.round(Math.random() * 100);
        System.out.println(r);
    }
}

✅ Aquí el casting es razonable porque sabemos que el resultado está en un rango pequeño.

👀 ¿Qué pasa si NO redondeo?

Si haces:

int r = (int) (Math.random() * 100);

Java corta los decimales (trunca), o sea que obtienes enteros… pero por truncamiento.

La clase Math en Java