La clase Math, situada en el paquete java.lang, nos provee de muchísimos métodos para para realizar las funciones matemáticas de uso más común.
La clase Math se encuentra situada en el paquete java.lang, esta es la razón por la que varias veces hemos utilizado esta clase sin necesidad de importarla. Recuerda que el paquete java.langse importa de manera implícita en todas las nuevas clases que creamos.
La clase Math tiene implementados muchos métodos estáticos que resuelven distintas tareas matemáticas. Al ser métodos estáticos pueden ser utilizados sin necesidad de construir un objeto. De hecho, nunca creamos un objeto de la clase Math.
Vamos a ir descubriendo poco a poco gran parte de lo que podemos hacer con la clase Math a través de ejemplos.
Las constantes PI y E
La clase Math dispone de las propiedades PI y E, que son variables estáticas y finales, es decir, pertenecen a la clase y son constantes. Contienen los clásicos valores matemáticos de PI (utilizado entre otras cosas para calcular la longitud y área de una circunferencia) y E (número irracional que se toma como base de los logaritmos neperianos).
|
1 2 3 4 5 6 7 8 |
public class Principal { public static void main(String[] args) { System.out.println("PI = " + Math.PI); System.out.println("E = " + Math.E); System.out.println("Longitud de la circunferencia de radio 30: " + (2*Math.PI*30)); } } |
Cálculo de la potencia
Java no tiene un operador específico para el cálculo de la potencia, esta se calcula con el método pow de la clase Math, cuyo formato es:
|
1 |
double Math.pow(double base, double exponente) |
La función pow recibe la base y el exponente y devuelve un número de tipo double con el resultado.
Veamos un ejemplo:
|
1 2 3 4 5 6 7 |
// Vamos a elevar al cubo public class Principal { public static void main(String[] args) { double base = 6; System.out.println(Math.pow(base, 3)); // 6 al cubo } } |
Conversión entre grados y radianes
La clase Math dispone de un par de métodos para convertir ángulos a radianes y viceversa. El formato de estos métodos el el siguiente:
|
1 2 |
double Math.toDegrees(double radianes) dobule Math.toRadians(double grados) |
Veamos un ejemplo:
|
1 2 3 4 5 6 7 8 9 10 |
public class Principal { public static void main(String[] args) { double grados = 30; double radianes = Math.toRadians(grados); System.out.println("Grados: " + grados); System.out.println("Conversión a radianes: " + radianes); System.out.println("Conversión a grados: " + Math.toDegrees(radianes)); } } |
Seno, coseno y tangente
Math dispone de un gran número de métodos para trabajar con ángulos. En esta ocasión trabajaremos con los métodos sen, cos y tan, que tienen el siguiente formato:
|
1 2 3 |
double Math.sin(radianes) double Math.cos(radianes) double Math.tan(radianes) |
Veamos un ejemplo:
|
1 2 3 4 5 6 7 8 9 |
public class Principal { public static void main(String[] args) { double grados = 30; double radianes = Math.toRadians(grados); System.out.println("Grados: " + grados); System.out.println("Radianes: " + radianes); System.out.println("Seno: " + Math.sin(radianes)); System.out.println("Coseno: " + Math.cos(radianes)); System.out.println("Tangente: " + Math.tan(radianes)); |
Redondeos: métodos ceil, floor y round
- Los métodos ceil, floor y round realizan el redondeo de un número real, pero de manera distinta.
- El método ceil realiza el redondeo al alza y deja cero en la parte decimal.
- El método floor realiza el redondeo a la baja y deja cero en la parte decimal.
- El método round realiza el redondeo al número más próximo y deja cero en la parte decimal. Aplica las reglas matemáticas del redondeo de números.
El formato de estos métodos es:
|
1 2 3 4 5 |
double Math.ceil(double num) double Math.floor(double num) double Math.round(double num) long Math.round(double num) int Math.round(float num) |
Observa que los métodos ceil y floor retornan un double, mientras que el método round está sobrecargado para retornar un long cuando recibe un double o retornar un int cuando recibe un float.
Veamos un ejemplo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
public class Principal { public static void main(String[] args) { // Redondeo al alza. System.out.println(Math.ceil(2.7)); // Muestra 3.0 System.out.println(Math.ceil(5.3)); // Muestra 6.0 System.out.println(Math.ceil(-5.3)); // Muestra -5.0 System.out.println(Math.ceil(-4.7)); // Muestra -4.0 // Redondeo la baja. System.out.println(Math.floor(2.7)); // Muestra 2.0 System.out.println(Math.floor(5.3)); // Muestra 5.0 System.out.println(Math.floor(-5.3)); // Muestra -6.0 System.out.println(Math.floor(-4.7)); // Muestra -5 // Redondeo al número más próximo. System.out.println(Math.round(2.7)); // Muestra 3 System.out.println(Math.round(5.3)); // Muestra 5 System.out.println(Math.round(-5.3)); // Muestra -5 System.out.println(Math.round(-4.7)); // Muestra -5 } } |
Generación de números al azar
La clase Math dispone de un método muy sencillo para generar números al azar con el siguiente formato:
|
1 |
double Math.random() |
La función random() devuelve un número al azar entre 0 (incluido) y 1 (sin incluir) con muchos decimales.
Prueba el siguiente código y ejecútalo muchas veces para comprobar que en cada ejecución sale un valor distinto:
|
1 2 3 4 5 6 |
public class Principal { public static void main(String[] args) { double x = Math.random(); System.out.println(x); } } |
A través de una serie de operaciones podemos convertir el número al azar entre 0 y 1 en un número al azar de cualquier rango. Vamos a ver algunos ejemplos:
|
1 2 3 4 5 6 |
public class Principal { public static void main(String[] args) { double x = Math.random()*10; System.out.println(x); } } |
Genera un número al azar entre 0 y 10 sin llegar a alcanzar el 10 y con decimales. Recuerda que random() genera un número entre 0 y 1 sin llegar al 1, luego el número mayor podría ser 0.999999999999999, que multiplicado por 10 será 9.99999999999999.
|
1 2 3 4 5 6 |
public class Principal { public static void main(String[] args) { double x = Math.ceil(Math.random()*10); System.out.println(x); } } |
En este caso, al aplicar el redondeo al alza, sí que alcanzaremos el número 10. Podríamos también obtener un 0, pero es muy improbable, ya que el número al azar generado tendría que ser 0.000000000000000.
|
1 2 3 4 5 6 |
public class Principal { public static void main(String[] args) { double x = Math.floor(Math.random()*10); System.out.println(x); } } |
En este caso, al aplicar el redondeo a la baja, estamos obteniendo un número del 0 al 9.
|
1 2 3 4 5 6 |
public class Principal { public static void main(String[] args) { Long x = Math.round(Math.random()*10); System.out.println(x); } } |
En este caso, al realizar el redondeo al número más próximo, estamos generando un número del 0 al 10.
|
1 2 3 4 5 6 |
public class Principal { public static void main(String[] args) { int x = (int) (Math.random()*10); System.out.println(x); } } |
En este caso, el generar un número al azar entre 0 y 1 (sin llegar al 1) y multiplicarlo por 10, estamos obteniendo un número entre 0 y 10 (sin llegar al 10) con muchos decimales. El número mayor posible será 9.999999999999999, pero al aplicar un cash y convertirlo a int estamos eliminando los decimales, de modo que estamos generando un número entre 0 y 9 sin decimales.
|
1 2 3 4 5 6 |
public class Principal { public static void main(String[] args) { int x = (int) (Math.random()*10)+1; System.out.println(x); } } |
Ahora estamos generando un número al azar entre 1 y 10.
En el caso de que desees generar números enteros al azar con cualquier rango DESDE … HASTA ambos incluidos, siempre puedes emplear esta fórmula:
(int)(Math.random()*(HASTA-DESDE+1)+DESDE);
|
1 2 3 4 5 6 7 8 |
public class Principal { public static void main(String[] args) { for (int i=1; i<=10; i++) { int azar = (int)(Math.random()*(20-10+1)+10); System.out.println(azar); } } } |
La clase Random
La clase Random, situada en el paquete java.util, nos brinda otra alternativa de obtener números al azar además del ya conocido método Math.random().
Para obtener números al azar lo primero que necesitamos es construir un objeto de la clase Random de la siguiente manera:
|
1 |
Random azar = new Random(); |
Ahora podemos utilizar los distintos métodos de la clase Random a través del objeto azar.
Método nextDouble()
El método nextDouble() devuelve un valor de tipo double como resultado de generar un número al azar entre 0 y 1 sin llegar a alcanzar el 1. Funciona exactamente igual que Math.random().
|
1 2 3 4 5 6 7 8 |
import java.util.Random; public class Principal { public static void main(String[] args) { Random azar = new Random(); double num = azar.nextDouble(); System.out.println(num); } } |
Método nextFloat()
El método nextFloat() devuelve un valor de tipo float como resultado de generar un número al azar entre 0 y 1 sin llegar a alcanzar el 1.
|
1 2 3 4 5 6 7 8 9 10 |
import java.util.Random; public class Principal { public static void main(String[] args) { Random azar = new Random(); float num = azar.nextFloat(); System.out.println(num); } } //Este programa funciona igual que el anterior, pero el número generado tiene menos precisión, es decir, tiene menos decimales. |
Método nextInt()
El método nextInt() devuelve un valor de tipo int resultado de generar un número al azar entre todos los posibles valores de un int (-2147483648 a 2147483647).
|
1 2 3 4 5 6 7 8 |
import java.util.Random; public class Principal { public static void main(String[] args) { Random azar = new Random(); int num = azar.nextInt(); System.out.println(num); } } |
Método nextInt(int hasta)
Esta implementación del método nextInt devuelve un número entre 0 y el valor introducido como argumento sin alcanzarlo.
|
1 2 3 4 5 6 7 8 9 |
import java.util.Random; public class Principal { public static void main(String[] args) { Random azar = new Random(); int num = azar.nextInt(6); System.out.println(num); } } //Este programa genera un número al azar entre 0 y 5. |
Método nextLong()
El método nextLong() devuelve un valor de tipo long resultado de generar un número al azar entre todos los posibles valores de un long (-9223372036854775808 a 9223372036854775807).
|
1 2 3 4 5 6 7 8 |
import java.util.Random; public class Principal { public static void main(String[] args) { Random azar = new Random(); long num = azar.nextLong(); System.out.println(num); } } |
Método nextBoolean()
El método nextBoolean() devuelve un valor al azar entre true o false.
|
1 2 3 4 5 6 7 8 9 10 11 |
import java.util.Random; public class Principal { public static void main(String[] args) { Random azar = new Random(); boolean siNo = azar.nextBoolean(); if (siNo) System.out.println("Hoy será un buen día"); else System.out.println("Lo siento, hoy será un día regular"); } } |
Utilizar el método Math.Random() resulta más sencillo y más eficiente porque no hay necesidad de instanciar una clase. Sin embargo, como has podido comprobar, la clase Random ofrece más posibilidades.