JAVA基础之Math类

1 ， Math 类概述

类包含用于执行基本数学运算的方法

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

Math 所有类都是静态的。可以直接类名。调用。

2 ，成员方法

public static int abs(int a)                                      // 取绝对值

public static double ceil(double a)                        //ceil 天花板 获取向上取整。结果是一个 double 类型

public static double floor(double a)                          //floor 地板 获取向下取整。结果是一个 double 类型

public static int max(int a,int b) min 自学                 // 获取两个值中的最大值。

public static double pow(double a,double b)        //  a 是底数。 b 是指数

public static double random()                                //0.0~1.0 之间的小数。包括 0.0 不包括 1.0

public static int round(float a) 参数为 double 的自学                 // 四舍五入

public static double sqrt(double a)                            // 平方根  

3 ， Math 类特点

由于 Math 类在 java.lang 包下，所以不需要导包。

因为它的成员全部是静态的 , 所以私有了构造方法  

4 ，获取随机数的方法

public static double random(): 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0 。

5 ，我要获取一个 1-100 之间的随机数，肿么办 ?

int number = (int)(Math.random()*100)+1;

/*

* A: 案例演示

* 需求：猜数字小游戏 ( 数据在 1-100 之间 )

*/

import java.util.Scanner;

class Test1_GuessNum

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);                // 创建键盘录入对象

System.out.println(" 请输入一个整数 , 范围在 1-100 之间 ");

int guessNum = (int)(Math.random() * 100) + 1;        // 心里想的随机数

while (true) {                                        // 因为需要猜很多次 , 所以用无限循环

int result = sc.nextInt();                        // 大家猜的数

if (result > guessNum) {                        // 如果你们猜的数大于了我心里想的数

System.out.println(" 大了 ");                    // 提示大了

} else if (result<guessNum) {                    // 如果你们猜的数小于了我心里想的数

System.out.println(" 小了 ");                    // 提示小了

} else {                                        // 如果既不大也不小

System.out.println(" 中了 ");                    // 中了

break;

}

}

}

}

6 ， Math  类应用  

public class Demo1_Math {

/**

* @param args

* * A:Math 类概述

* Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

* B: 成员方法

* public static int abs(int a)

* public static double ceil(double a)

* public static double floor(double a)

* public static int max(int a,int b) min 自学

* public static double pow(double a,double b)

* public static double random()

* public static int round(float a) 参数为 double 的自学

* public static double sqrt(double a)

*/

public static void main(String[] args) {

System.out.println(Math.PI);

System.out.println(Math.abs(-10));              // 取绝对值

//ceil 天花板

/*

* 13.0

* 12.3

* 12.0

*/

System.out.println(Math.ceil(12.3));            // 向上取整 , 但是结果是一个 double

System.out.println(Math.ceil(12.99));

System.out.println("-----------");

//floor 地板

/*

* 13.0

* 12.3

* 12.0

*/

System.out.println(Math.floor(12.3));            // 向下取整 , 但是结果是一个 double

System.out.println(Math.floor(12.99));

// 获取两个值中的最大值

System.out.println(Math.max(20, 30));

// 前面的数是底数 , 后面的数是指数

System.out.println(Math.pow(2, 3));                //2.0 ^ 3.0

// 生成 0.0 到 1.0 之间的所以小数 , 包括 0.0, 不包括 1.0

System.out.println(Math.random())

// 四舍五入

System.out.println(Math.round(12.3f));

System.out.println(Math.round(12.9f));

// 开平方

System.out.println(Math.sqrt(4));

System.out.println(Math.sqrt(2));

System.out.println(Math.sqrt(3));

}

}

/**

* 常量

*/

System.out.println("------>" + Math.E);//2.718281828459045

System.out.println("------>" + Math.PI);//3.141592653589793

/**

* Math.abs() 计算绝对值

*/

System.out.println("------>" + Math.abs(-3));//3

/**

* 三角函数与反三角函数

* cos 求余弦

* sin 求正弦

* tan 求正切

* acos 求反余弦

* asin 求反正弦

* atan 求反正切

* atan2(y,x) 求向量 (x,y) 与 x 轴夹角

* cosh 计算值的双曲余弦

* sinh 计算双曲正弦

* tanh 计算双曲正切

*/

System.out.println("------>" + Math.acos(1));

System.out.println("------>" + Math.acos(-1));

/**

* Math.cbrt() 开立方根

*/

System.out.println("------>" + Math.cbrt(-1));//-1.0

System.out.println("------>" + Math.cbrt(1));//1.0

System.out.println("------>" + Math.cbrt(0.5));//0.7937005259840998

System.out.println("------>" + Math.cbrt(5));//1.709975946676697

/**

* Math.sqrt(x) 开平方

*/

System.out.println("------>" + Math.sqrt(4.0));//2.0

/**

* Math.hypot(x,y) 求 sqrt(x*x+y*y) 在求两点间距离时有用 sqrt((x1-x2)^2+(y1-y2)^2)

*/

System.out.println("------>" + Math.hypot(3.0, 4.0));//5.0

/**

* ceil 天花板，向上取整，返回大的值

*/

System.out.println("------1>" + Math.ceil(7.2));//8.0

System.out.println("------2>" + Math.ceil(7.5));//8.0

System.out.println("------3>" + Math.ceil(7.6));//8.0

System.out.println("------4>" + Math.ceil(-7.2));//-7.0

System.out.println("------5>" + Math.ceil(-7.5));//-7.0

System.out.println("------6>" + Math.ceil(-7.6));//-7.0

/**

* floor 地板，向下取整，返回小的值

*/

System.out.println("------1>" + Math.floor(7.2));//7.0

System.out.println("------2>" + Math.floor(7.5));//7.0

System.out.println("------3>" + Math.floor(7.6));//7.0

System.out.println("------4>" + Math.floor(-7.2));//-8.0

System.out.println("------5>" + Math.floor(-7.5));//-8.0

System.out.println("------6>" + Math.floor(-7.6));//-8.0

/**

* Math.cosh() 返回 double 值的双曲线余弦。 x 的双曲线余弦的定义是 (ex + e-x)/2 ，其中 e 是欧拉数

*/

System.out.println("------>" + Math.cosh(1));//1.543080634815244

System.out.println("------>" + Math.cosh(0));//1.0

/**

* exp(x) 返回 e^x 的值

* expm1(x) 返回 e^x - 1 的值

* pow(x,y) 返回 x^y 的值

* 这里可用的数据类型也只有 double 型

*/

System.out.println("------>" + Math.exp(2));//7.38905609893065

System.out.println("------>" + Math.expm1(2));//6.38905609893065

System.out.println("------>" + Math.pow(2.0, 3.0));//8.0

/**

* 对数

* Math.log(a) a 的自然对数 ( 底数是 e)

* Math.log10(a) a 的底数为 10 的对数

* Math.log1p(a) a+1 的自然对数

* 值得注意的是，前面其他函数都有重载，对数运算的函数只能传 double 型数据并返回 double 型数据

*/

System.out.println("------1>" + Math.log(Math.E));//1.0

System.out.println("------2>" + Math.log10(10));//1.0

System.out.println("------3>" + Math.log1p(Math.E - 1.0));//1.0

/**

* Math.max() 求最大值

* Math.min() 求最小值

*/

System.out.println("------1>" + Math.max(1, 2));//2

System.out.println("------2>" + Math.min(1, -2));//-2

/**

* Math.nextAfter() 返回与第二个参数方向相邻的第一个参数的浮点数。

*/

System.out.println("------1>" + Math.nextAfter(-1, 2));//-0.99999994

System.out.println("------2>" + Math.nextAfter(1, 2));//1.0000001

/**

* Math.nextUp() 返回与正无穷大方向相邻的 d 的浮点值。

*/

System.out.println("------>" + Math.nextUp(1));//1.0000001

System.out.println("------>" + Math.nextUp(-1));//-0.99999994

/**

* Math.Random() 函数能够返回带正号的 double 值，该值大于等于 0.0 且小于 1.0 ，即取值范围是 [0.0,1.0) 的左闭右开区间，

* 返回值是一个伪随机选择的数，在该范围内（近似）均匀分布

*/

System.out.println("------>" + Math.random());// 取值范围是 [0.0,1.0) 的随机数

/**

* Math.rint(x) ： x 取整为它最接近的整数，如果 x 与两个整数的距离相等，则返回其中为偶数的那一个。

*/

System.out.println("------>" + Math.rint(3.5));//4.0

System.out.println("------>" + Math.rint(4.5));//4.0

System.out.println("------>" + Math.rint(3.1));//3.0

System.out.println("------>" + Math.rint(4.1));//4.0

System.out.println("------>" + Math.rint(3.7));//4.0

System.out.println("------>" + Math.rint(4.7));//5.0

/**

* Math.round(x) ：返回 Math.floor(x+0.5) ，即“四舍五入”值。

*/

System.out.println("------>" + Math.round(3.5));//4

System.out.println("------>" + Math.round(4.5));//5

System.out.println("------>" + Math.round(3.1));//3

System.out.println("------>" + Math.round(4.7));//5

/**

* Math.scalb(double d, int scaleFactor), 返回 f × 2scaleFactor ，其舍入方式如同将一个正确舍入的浮点值乘以 float

* 值集合中的一个值

* 返回 d 和正无穷大之间与 d 相邻的 外汇返佣 浮点值 tatic double   nextUp(double d)

*/

System.out.println("------1>" + Math.scalb(1.5d, 6));//96

/**

* Math.scalb(float f, int scaleFactor)

* 返回 f 和正无穷大之间与 f 相邻的浮点值 tatic float    nextUp(float f)

* 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数

*/

System.out.println("------2>" + Math.scalb(1.5f, 6));//96

/**

* Math.signum 方法返回指定 int 值的符号函数（如果指定值为负，则返回 -1 ；如果指定值为零，则返回 0 ；如果指定值为正，则返回 1 ）。

*/

System.out.println("------1>" + Math.signum(10));//1.0

System.out.println("------2>" + Math.signum(-10));//-1.0

System.out.println("------3>" + Math.signum(0));//0.0

/**

* Math.toDegrees() 将弧度转换角度

*/

System.out.println("------3>" + Math.toDegrees(1.57));//89.95437383553926

/**

* Math.toRadians() 将角度转换为弧度

*/

System.out.println("------3>" + Math.toRadians(90));//1.5707963267948966

/**

* Math.ulp()

* 如果要理解什么是 ulp(unit in the last place or unit of least precision (ULP))

* 先要了解在计算机中保存的数和我们在数学上认为的数是不一样的；

* 比方说 2.0 和 3.0 之间有多少个数，在数学中是无限的，但是在计算机中是有限的，

* 因为计算机需要用一堆字节来表示 double 或者 float, 但是因为计算机表示不了无限的数（因为没有无限内存）。

*

* 所以就有了 ulp ，假设在 float 2.0 和 3.0 之间有 8,388,609 个数，那么在 2.0 和 3.0 之间的数的 ulp 就是 8,388,609/1.0 约等于 0.0000001 。

*

* 你如果想知道某一个具体的 double 或 float 的先一个或者上一个数字是什么可以使用函数

* public static double nextAfter(float start, float direction)

* public static double nextAfter(double start, double direction)

*/

/**

* java8 Math 新增方法

*/

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

/**

* Math.addExact() 求和，如果结果溢出取值范围，则引发异常。

*/

System.out.println("------>" + Math.addExact(1, 2));//3

/**

* Math.substractExact() 方法返回两个参数之差，结果溢出时抛出 ArithmeticException

*/

System.out.println("------>" + Math.subtractExact(100, 50));//50

/**

* Math.incrementExact() 方法 返回参数值加一，结果溢出时抛出 ArithmeticException

*/

System.out.println("------>" + Math.incrementExact(100));//101

/**

* Math.decrementExact() 方法 返回参数值减一，结果溢出时抛出 ArithmeticException

*/

System.out.println("------>" + Math.decrementExact(100));//99

/**

* Math.multiplyExact() 方法 返回两个参数之积，结果溢出时抛出 ArithmeticException

*/

System.out.println("------>" + Math.multiplyExact(100, 5));//500

/**

* Math.negateExact() 方法 改变参数符号，结果溢出时抛出 ArithmeticException

*/

System.out.println("------>" + Math.negateExact(100));//-100

/**

* Math.floorDiv(1,2) 第一个参数除以第二参数，然后针对结果执行 floor 操作，返回小于或等于商的整数：

*/

System.out.println("------>" + Math.floorDiv(7, 3));//2

System.out.println("------>" + Math.floorDiv(-7, 3));//-3

/**

* Math.floorMod()

* 1 、如果参数的符号相同，则 floorMod 和％运算符的结果是相同的。

* 2 、如果参数的符号不同，则结果与％运算符不同。

*/

// 如果参数的符号相同，则 floorMod 和％运算符的结果是相同的。

System.out.println("------1>" + Math.floorMod(4, 3));//1

System.out.println("------2>" + (4 % 3));//1

// 如果参数的符号不同，则结果与％运算符不同。

System.out.println("------3>" + Math.floorMod(4, -3));//-2

System.out.println("------4>" + (4 % -3));//1

System.out.println("------5>" + Math.floorMod(-4, 3));//2

System.out.println("------6>" + (-4 % 3));//-1

System.out.println("------7>" + Math.floorMod(-4, -3));//-1

System.out.println("------8>" + (-4 % -3));//-1

/**

* Math.toIntExact(),long 转 int

*/

System.out.println("------1>" + Math.toIntExact(1));

/**

* Math.nextDown() 返回与负无穷大方向相邻的 f 的浮点值。

*/

System.out.println("------>" + Math.nextDown(1));//0.99999994

System.out.println("------>" + Math.nextDown(-1));//-1.0000001

}