Tổng hợp tất cả các hàm toán học trong java – Math class

Math class trong java cung cấp cho chúng ta các hàm hỗ trợ tính toán nâng cao như tính sin, cos, căn bậc 2, làm tròn etc. Sử dụng tốt Math class khiến cho việc lập trình của chúng ta trở nên đơn giản hơn, dưới đây là tổng hợp các phép tính mà Math class hỗ trợ.

Trị tuyệt đối trong java -Math.abs()

Math.abs() trả về giá trị tuyệt đối của tham số truyền vào. Matt.abs() có 4 overload method sau:

Math.abs(int)
Math.abs(long)
Math.abs(float)
Math.abs(double)

public class Main {

    public static void main(String[] args) {
        int x = 10;

        int y = -20;

        System.out.println(Math.abs(x - y)); // 30

        System.out.println(Math.abs(y - x)); // 30

        System.out.println(Math.abs(y)); // 20

        System.out.println(Math.abs(x)); // 10
    }
}

Làm tròn lên trong java – Math.ceil()

Math.ceil() làm tròn lên một giá trị floating-point đến giá trị integer gần nhất.

public class Main {

    public static void main(String[] args) {
        int i = 5;
        float f = 5.4f;
        double d = 5.224d;

        double ri = Math.ceil(i); // 5.0

        double rf = Math.ceil(f); // 6.0

        double rd = Math.ceil(d); // 6.0
    }
}

Làm tròn xuống trong java – Math.floor()

Math.floor() làm tròn xuống một giá trị floating-point đến giá trị integer gần nhất.

public class Main {

    public static void main(String[] args) {
        int i = 5;
        float f = 5.4f;
        double d = 5.224d;

        double ri = Math.floor(i); // 5.0

        double rf = Math.floor(f); // 5.0

        double rd = Math.floor(d); // 5.0
    }
}

Chia 2 số nguyên và làm tròn – floorDiv()

Math.floorDiv() chia 1 số nguyên(int/long) với một số khác, và làm tròn xuống giá trị integer gần nhất.

public class Main {

    public static void main(String[] args) {
        double result1 = Math.floorDiv(-100,9);
        System.out.println("result: " + result1);

        double result2 = -100 / 9;
        System.out.println("result: " + result2);

        double result3 = Math.floorDiv(100,9);
        System.out.println("result: " + result3);

        double result4 = 100 / 9;
        System.out.println("result: " + result4);
    }
}

Note: -100/9 = -11.111.. thì kết quả làm tròn xuống là -12 nhé.

Lấy số nhỏ nhất trong 2 số – Math.min()

Math.min() trả về số nhỏ nhất trong 2 tham số đầu vào. Math.min() có 4 overload method.

Math.min(int, int)
Math.min(long, long)
Math.min(float, float)
Math.min(double, double)

public class Main {

    public static void main(String[] args) {

        int i = Math.min(1, 2); // 1

        float f = Math.min(3.4f, 3.5f); // 3.4f

        float f1 = Math.min(3, 3.5f); // 3

        double d = Math.min(3.434d, 3.435d); // 3.434d

        double d1 = Math.min(3, 3.345d); // 3

        double d2 = Math.min(3.5f, 3.345d); // 3.345d

    }
}

Lấy số lớn nhất trong 2 số – Math.max()

Math.max() trả về số lớn nhất trong 2 tham số đầu vào. Math.max() có 4 overload method.

Math.math(int, int)
Math.math(long, long)
Math.math(float, float)
Math.math(double, double)

public class Main {

    public static void main(String[] args) {

        int i = Math.max(1, 2); // 2

        float f = Math.max(3.4f, 3.5f); // 3.5f

        float f1 = Math.max(3, 3.5f); // 3.5

        double d = Math.max(3.434d, 3.435d); // 3.435d

        double d1 = Math.max(3, 3.345d); // 3.345d

        double d2 = Math.max(3.5f, 3.345d); // 3.5

    }
}

Làm tròn trong java – Math.round()

Math.round() làm tròn số theo quy luật thông thường trong toán học. Math.round() có 2 overload method

Math.round(float, float)

Math.round(double, double)

double roundedDown = Math.round(23.445); // 23

double roundedUp   = Math.round(23.545); // 24

Random trong java – Math.random()

Math.random() trả một một float-point trong khoảng 0 đến 1.

double random = Math.random();

Nếu bạn muốn random số nguyên ngẫu nhiên trong khoảng 0 đến 100 có thể kết hợp Math.random() với round(), ceil(), floor().

System.out.println(Math.ceil(Math.random() * 100D));

Số mũ và Logarit trong java

Math class cũng chứa một tập các method hỗ trợ exponential và Logarithmic.

Tính số mũ hằng số e(Euler’s number) – Math.exp() 

Math.exp() trả số mũ n trong tham số truyền vào của hằng số e.

double exp1 = Math.exp(1); // 2.718281828459045

double exp2 = Math.exp(2); // 7.38905609893065

Logarit cơ số e – Math.log()

Math.log() trả về logarit cơ số e của n là tham số đầu vào.

double t1 = Math.log(1); // 0.0

double t2 = Math.log(2); // 0.6931471805599453

Logarit cơ số 10 – Math.log10()

Math.log10() trả về logarit cơ số 10 của n là tham số đầu vào.

double t1 = Math.log10(1); // 0.0

double t2 = Math.log10(100); // 2.0

Luỹ thừa trong java – Math.pow()

Math.pow(double t1, double t2) nhận vào 2 tham số t1, t2, trong đó t1 là số được luỹ thừa lên t2 lần.

double pow2 = Math.pow(2,2); // 4.0

double pow8 = Math.pow(2,8); // 256

Căn bậc 2 trong java – Math.sqrt()

Math.sqrt() trả về giá trị căn bậc 2 của tham số truyền vào.

double sqrt4 = Math.sqrt(4); // 2.0

double sqrt9 = Math.sqrt(9); // 3.0

Hàm lượng giác trong java

Hằng số PI – Math.PI 

Math.PI là một hằng số kiểu double trong Math class chứa giá trị của hằng số PI trong toán học. 

Math.sin()

Math.sin() trả về giá trị sin của một góc tính theo đơn vị radian. Lưu ý công thức chuyển từ độ sang radian là  (độ / 180 * PI). Chúng ta có thể dùng toRadians() để chuyển từ độ sang radian.

double value = Math.sin(Math.toRadians(30)); // 0.49999999999999994

Math.cos()

Math.cos() trả về giá trị cos của một góc tính theo đơn vị radian.

double value = Math.cos(Math.toRadians(60)); // 0.5000000000000001

Math.tan()

Math.tan() trả về giá trị tan của một góc tính theo đơn vị radian.

double value = Math.tan(Math.toRadians(45)); // 0.9999999999999999

Math.asin()

Math.asin() trả về giá trị arc sine.

double sin = Math.sin(Math.toRadians(30)); // 0.49999999999999994

double arsin = Math.asin(sin); // 0.5235987755982988

Math.acos()

Math.acos() trả về giá trị arc cose.

double cos = Math.cos(Math.toRadians(60)); // 0.5000000000000001

double arcos = Math.acos(cos); // 1.0471975511965976

Math.atan()

Math.atan() trả về giá trị arc tane.

double tan = Math.cos(Math.toRadians(45)); // 0.7071067811865476

double artan = Math.atan(tan); // 0.6154797086703874

Math.sinh()

Trả về giá trị hyperbolic sine.

// get two double numbers numbers
double x = 45;
double y = -180;

// convert them to radians
x = Math.toRadians(x);
y = Math.toRadians(y);

// print the hyperbolic sine for these doubles
System.out.println("sinh(" + x + ")=" + Math.sinh(x)); // sinh(0.7853981633974483)=0.8686709614860095
System.out.println("sinh(" + y + ")=" + Math.sinh(y)); // sinh(-3.141592653589793)=-11.548739357257748

Math.cosh()

Trả về giá trị hyperbolic cose.

double x = 45.0;
double y = 180.0;

// convert them to radians
x = Math.toRadians(x);
y = Math.toRadians(y);

// print their hyperbolic cosine
System.out.println("Math.cosh(" + x + ")=" + Math.cosh(x)); // Math.cosh(0.7853981633974483)=1.3246090892520057
System.out.println("Math.cosh(" + y + ")=" + Math.cosh(y)); //Math.cosh(3.141592653589793)=11.591953275521519

Math.tanh()

Trả về giá trị hyperbolic tane.

// get two double numbers numbers
double x = 45;
double y = -180;

// convert them in radians
x = Math.toRadians(x);
y = Math.toRadians(y);

// print the hyperbolic tangent of these doubles
System.out.println("Math.tanh(" + x + ")=" + Math.tanh(x)); // Math.tanh(0.7853981633974483)=0.6557942026326724
System.out.println("Math.tanh(" + y + ")=" + Math.tanh(y)); // Math.tanh(-3.141592653589793)=-0.99627207622075

Math.toDegrees()

Math.toDegrees() chuyển góc radian thành độ

double goc = Math.toDegrees(Math.PI/2); //90

Math.toRadians()

Math.toRadians() Chuyển độ sang radian.

double goc = Math.toRadians(45);//0.7853981633974483

Nguồn tham khảo

http://tutorials.jenkov.com/java/math-operators-and-math-class.html

https://www.tutorialspoint.com/java/lang/math_sinh.htm

https://www.tutorialspoint.com/java/lang/math_cosh.htm