概述
不可变类且无法对该类进行初始化
public final class Math {
/**
* Don't let anyone instantiate this class.
*/
private Math() {}
}成员变量
//double值,比其他任何一个都更接近 e ，自然对数的基数。
public static final double E = 2.7182818284590452354;
//double值,比任何其他的更接近 pi ，圆周长与其直径的比率。
public static final double PI = 3.14159265358979323846;方法
三角函数
角度转三角函数值
/**
返回角度的三角正弦。 特殊情况：
如果参数为NaN或无穷大，则结果为NaN。
如果参数为零，则结果为与参数相同符号的零。
a 以弧度表示的角度。
**/
public static double sin(double a) {}
/**
返回角度的三角余弦。 特殊情况：
如果参数为NaN或无穷大，则结果为NaN。
a - 以弧度表示的角度
**/
public static double cos(double a) {}
/**
返回角度的三角正切。 特殊情况：
如果参数为NaN或无穷大，则结果为NaN。
如果参数为零，则结果为与参数相同符号的零。
a - 以弧度表示的角度。
**/
public static double tan(double a) {}三角函数值转角度
/**
返回值的正弦值; 返回角度在-pi / 2到pi / 2的范围内。 特殊情况：
如果参数为NaN或其绝对值大于1，则结果为NaN。
如果参数为零，则结果为与参数相同符号的零。
a - 要返回正弦的值。
**/
public static double asin(double a) {}
/**
返回值的反余弦值; 返回的角度在0.0到pi的范围内。 特例：
如果参数为NaN或其绝对值大于1，则结果为NaN。
a - 要返回的余弦值。
**/
public static double acos(double a) {}
/**
返回值的反正切值; 返回角度在-pi / 2到pi / 2的范围内。 特殊情况：
如果参数是NaN，那么结果是NaN。
如果参数为零，则结果为与参数相同符号的零。
a - 要返回的反正切值。
**/
public static double atan(double a) {}示例
@Test
public void test2() {
System.out.println(Math.sin(Math.PI / 2));// 1.0
System.out.println(Math.cos(Math.PI / 2));// 6.123233995736766E-17
System.out.println(Math.tan(Math.PI / 4));// 0.9999999999999999
System.out.println(Math.PI / 2);// 1.5707963267948966
System.out.println(Math.asin(1));// 1.5707963267948966
System.out.println(Math.acos(0));// 1.5707963267948966
System.out.println(Math.PI / 4);// 0.7853981633974483
System.out.println(Math.atan(1));// 0.7853981633974483
}弧度角度转换
//将以度为单位的角度转换为以弧度测量的大致相等的角度。 从度数到弧度的转换通常是不准确的。
//angdeg - 以度为单位的角度
public static double toRadians(double angdeg) {}
//将以弧度测量的角度转换为以度为单位的近似等效角度。 从弧度到度的转换通常是不准确的; 用户不应该指望cos(toRadians(90.0))正好等于0.0 。
//angrad - 以弧度表示的角度
public static double toDegrees(double angrad) {}对数、指数、开方、立方、sqrt（ x^ 2 + y ^2 ），
/**
返回欧拉的数字e提高到double价值。 特殊情况：
如果参数是NaN，结果是NaN。
如果参数为无穷大，则结果为正无穷大。
如果参数为负无穷大，则结果为正零。
结果 ：
值 e^a ，其中 e是自然对数的基数。
**/
public static double exp(double a) {}
/**
返回的自然对数（以e为底） double值。 特殊情况：
如果参数为NaN或小于零，则结果为NaN。
如果参数为无穷大，则结果为正无穷大。
如果参数为正零或负零，则结果为负无穷大
结果：
值ln a ，自然对数为 a 。
**/
public static double log(double a) {}
/**
返回一个double的基数10对数值。 特殊情况：
如果参数为NaN或小于零，则结果为NaN。
如果参数为无穷大，则结果为正无穷大。
如果参数为正零或负零，则结果为负无穷大。
如果参数等于10 n，用于整数n，则结果为n。
结果 :
基数10对数为 a
**/
public static double log10(double a) {}
/**
返回double值正确舍入的正平方根。 特殊情况：
如果参数为NaN或小于零，则结果为NaN。
如果参数为无穷大，则结果为正无穷大。
如果参数为正零或负零，则结果与参数相同。
结果
a开平方
**/
public static double sqrt(double a) {}
/**
如果参数是NaN，那么结果是NaN。
如果参数是无限的，则结果是与参数具有相同符号的无穷大。
如果参数为零，则结果为与参数相同符号的零。
结果
a开立方
**/
public static double cbrt(double a) {}
//结果 a^b
public static double pow(double a, double b) {}
/**
如果任一参数为无穷大，则结果为无穷大。
如果任一参数为NaN，且两个参数都不是无穷大，则结果为NaN。
sqrt（ x 2 + y 2 ），没有中间溢出或下溢
**/
public static double hypot(double x, double y) {}求和、差、积、递增、递减、绝对值
//求和，如果结果溢出就抛异常
public static int addExact(int x, int y) {}
//求和，如果结果溢出就抛异常
public static long addExact(long x, long y) {}
//求差 x-y，如果结果溢出抛异常
public static int subtractExact(int x, int y) {}
//求差 x-y，如果结果溢出抛异常
public static long subtractExact(long x, long y) {}
//求积，如果结果溢出就抛异常
public static int multiplyExact(int x, int y) {}
//求积，如果结果溢出就抛异常
public static long multiplyExact(long x, long y) {}
//递增a+1，如果溢出就抛异常
public static int incrementExact(int a) {}
//递增a+1，如果溢出就抛异常
public static long incrementExact(long a) {}
//递减a-1，如果溢出就抛异常
public static int decrementExact(int a) {}
//递减a-1，如果溢出就抛异常
public static long decrementExact(long a) {}
//求相反数，当a为最小int值时，相反数溢出抛异常
public static int negateExact(int a) {}
//求相反数，当a为最小long 值时，相反数溢出抛异常
public static long negateExact(long a) {}
//取绝对值
public static int abs(int a) {}
public static long abs(long a) {}
public static float abs(float a) {}
public static double abs(double a) {}绝对值、最大值、最小值
//取绝对值
public static int abs(int a) {}
public static long abs(long a) {}
public static float abs(float a) {}
public static double abs(double a) {}
//最大值
public static int max(int a, int b) {}
public static long max(long a, long b) {}
public static float max(float a, float b) {}
public static double max(double a, double b) {}
//最小值
public static int min(int a, int b) {}
public static long min(long a, long b) {}
public static float min(float a, float b) {}
public static double min(double a, double b) {}特殊运算
//结果x÷y，对商进行Math.floor的取值（示例）
public static int floorDiv(int x, int y) {}
//结果x÷y，对商进行Math.floor的取值（示例）
public static long floorDiv(long x, long y) {}
/**
如果参数的符号相同， floorMod和%操作符的结果是一样的。
floorMod(4, 3) == 1 ; 和(4 % 3) == 1
如果参数的符号不同，结果与%运算符不同。
floorMod(+4, -3) == -2 ; 和(+4 % -3) == +1
floorMod(-4, +3) == +2 ; 和(-4 % +3) == -1
floorMod(-4, -3) == -1 ; 和(-4 % -3) == -1
**/
public static int floorMod(int x, int y) {}
public static long floorMod(long x, long y) {}
//取参数的符号
public static double signum(double d) {}
public static float signum(float f) {}示例
@Test
public void test4() {
//如果参数的符号相同，那么floorDiv和/操作符的结果是一样的。
System.out.println(Math.floorDiv(4, 3));//1
System.out.println((4 / 3));//1
//如果参数的符号不同，则商为负， floorDiv返回小于或等于商的整数， /操作符返回最接近零的整数。
System.out.println(Math.floorDiv(-4, 3));//-2
System.out.println((-4 / 3));//-1
}取值
/**
返回大于或等于参数的最小（最接近负无穷大） double值，并等于数学整数。 特殊情况：
如果参数值已经等于数学整数，则结果与参数相同。
如果参数为NaN或无穷大或正零或负零，则结果与参数相同。
如果参数值小于零但大于-1.0，则结果为负零。
**/
public static double ceil(double a) {}
/**
返回小于或等于参数的最大（最接近正无穷大） double值，等于数学整数。 特殊情况：
如果参数值已经等于数学整数，则结果与参数相同。
如果参数为NaN或无穷大或正零或负零，则结果与参数相同。
**/
public static double floor(double a) {}
/**
返回与参数最接近值的double值，等于数学整数。 如果作为数学整数的两个double值同样接近，则结果为均匀的整数值。 特殊情况：
如果参数值已经等于数学整数，则结果与参数相同。
如果参数为NaN或无穷大或正零或负零，则结果与参数相同。
当a大于0时，与四舍五入保留整数类似，返回的是double类型
小于0，不同看示例
**/
public static double rint(double a) {}
/**
如果参数是NaN，结果为0。
如果参数为负无穷大或小于或等于Integer.MIN_VALUE的值，则结果等于Integer.MIN_VALUE的值。
如果参数为正无穷大或大于或等于Integer.MAX_VALUE的值，则结果等于Integer.MAX_VALUE的值。
参数的值四舍五入到最接近的 int值
**/
public static int round(float a) {}
/**
如果参数是NaN，结果为0。
如果参数为负无穷大或小于或等于Long.MIN_VALUE的值，则结果等于Long.MIN_VALUE的值。
如果参数为正无穷大或大于或等于Long.MAX_VALUE的值，则结果等于Long.MAX_VALUE的值。
参数的值四舍五入到最接近的 int值
**/
public static long round(double a) {}
//返回一个double值为正号，大于等于0.0 ，小于1.0 。 返回的值是从该范围（大约）均匀分布而伪随机选择的。
//调用Random.nextDouble()
public static double random() {}示例
@Test
public void test3() {
System.out.println(Math.ceil(0.2));//1.0
System.out.println(Math.ceil(1.2));//2.0
System.out.println(Math.ceil(-0.2));//-0.0
System.out.println(Math.ceil(-1.2));//-1.0
System.out.println(Math.ceil(-5.5));//-5.0
System.out.println(Math.floor(0.2));//0.0
System.out.println(Math.floor(1.2));//1.0
System.out.println(Math.floor(-0.2));//-1.0
System.out.println(Math.floor(-1.2));//-2.0
System.out.println(Math.floor(-5.5));//-6.0
System.out.println(Math.rint(0.2));//0.0
System.out.println(Math.rint(1.2));//1.0
System.out.println(Math.rint(-0.2));//-0.0
System.out.println(Math.rint(-1.2));//-1.0
System.out.println(Math.rint(-5.5));//-6.0
//注意
System.out.println(Math.rint(-5.5));//-6.0
System.out.println(Math.rint(5.5));//6.0
System.out.println(Math.round(-5.5));//-5.0
System.out.println(Math.round(5.5));//6.0
}转化
//long转int，如果long超出int范围抛异常
public static int toIntExact(long value) {}
//使用第二个浮点参数的符号返回第一个浮点参数。
public static double copySign(double magnitude, double sign) {}
public static float copySign(float magnitude, float sign) {}未知
//不知道干嘛
public static double IEEEremainder(double f1, double f2) {}
public static double atan2(double y, double x) {}
public static double ulp(double d) {}
public static float ulp(float f) {}
public static double sinh(double x) {}
public static double cosh(double x) {}
public static double tanh(double x) {}
public static double expm1(double x) {}
public static double log1p(double x) {}
public static int getExponent(float f) {}
public static int getExponent(double d) {}
public static double nextAfter(double start, double direction) {}
public static float nextAfter(float start, double direction) {}
public static double nextUp(double d) {}
public static float nextUp(float f) {}
public static double nextDown(double d) {}
public static float nextDown(float f) {}
public static double scalb(double d, int scaleFactor) {}
public static float scalb(float f, int scaleFactor) {}