```
public final class Mathextends Object
```
类Math包含用于执行基本数字运算的方法，例如基本指数，对数，平方根和三角函数。
不像一些类的数值方法StrictMath ，类相当于所有功能的实现Math没有定义返回位对位相同的结果。这种放松允许在不需要严格再现性的情况下实现更好的实施。

默认情况下，许多Math方法只需调用中的对应方法是StrictMath组织落实。鼓励代码生成器使用特定于平台的本机库或微处理器指令（如果可用），以提供Math方法的更高性能实现。此类更高性能的实现仍必须符合Math的规范。

实现规范的质量涉及两个属性，返回结果的准确性和方法的单调性。的浮点精度Math方法在ULPS，单位在最后的地方来衡量。对于给定的浮点格式，特定实数值的ulp是包围该数值的两个浮点值之间的距离。在讨论整个方法的准确性而不是特定的参数时，引用的ulps数量是针对任何参数的最坏情况误差。如果方法的错误总是小于0.5 ulps，则该方法始终返回最接近精确结果的浮点数; 这样的方法是正确的舍入 。正确舍入的方法通常是浮点近似的最佳方法; 但是，对于许多浮点方法来说，正确舍入是不切实际的。相反，对于Math类，某些方法允许使用1或2 Math的较大误差范围。非正式地，当1 ulp错误界限时，如果确切结果是可表示的数字，则应将精确结果作为计算结果返回; 否则，可以返回包含确切结果的两个浮点值中的任何一个。对于幅度较大的精确结果，括号的一个端点可能是无限的。除了单个参数的准确性之外，在不同参数下维持方法之间的正确关系也很重要。因此，大多数超过0.5 ulp误差的方法都需要是半单调的 ：每当数学函数不递减时，浮点近似也是如此，同样，只要数学函数不增加，浮动也是如此。点近似。并非所有具有1 ulp精度的近似值都将自动满足单调性要求。

该平台使用带有int和long基本类型的带符号二进制补码整数算法。开发人员应选择基本类型以确保算术运算始终产生正确的结果，这在某些情况下意味着操作不会溢出计算值的范围。最佳实践是选择基本类型和算法以避免溢出。在情况下，大小为int或long ，需要检测溢出错误，方法addExact ， subtractExact ， multiplyExact和toIntExact抛出ArithmeticException结果溢出时。对于其他算术运算，例如除法，绝对值，递增1，递减1和否定，溢出仅在特定的最小值或最大值时发生，应根据需要检查最小值或最大值。

从以下版本开始：

1.0

字段汇总

字段
变量和类型	字段	描述
`static double`	`E`	`double`值比任何其他值更接近 e ，即自然对数的基数。
`static double`	`PI`	`double`值比任何其他 pi更接近，圆的圆周与其直径的比率。

方法摘要

所有方法静态方法具体的方法
变量和类型	方法	描述
`static double`	`abs(double a)`	返回 `double`值的绝对值。
`static float`	`abs(float a)`	返回 `float`值的绝对值。
`static int`	`abs(int a)`	返回 `int`值的绝对值。
`static long`	`abs(long a)`	返回 `long`值的绝对值。
`static double`	`acos(double a)`	返回值的反余弦值; 返回的角度在0.0到pi的范围内。
`static int`	`addExact(int x, int y)`	返回其参数的总和，如果结果溢出 `int`则抛出异常。
`static long`	`addExact(long x, long y)`	返回其参数的总和，如果结果溢出 `long`则抛出异常。
`static double`	`asin(double a)`	返回值的反正弦值; 返回的角度在-pi / 2到pi / 2的范围内。
`static double`	`atan(double a)`	返回值的反正切值; 返回的角度在-pi / 2到pi / 2的范围内。
`static double`	`atan2(double y, double x)`	返回从直角坐标（转换角度 theta `x` ， `y` ）为极坐标（R，θ-）。
`static double`	`cbrt(double a)`	返回 `double`值的多维数据集根。
`static double`	`ceil(double a)`	返回大于或等于参数且等于数学整数的最小值（最接近负无穷大） `double` 。
`static double`	`copySign(double magnitude, double sign)`	返回带有第二个浮点参数符号的第一个浮点参数。
`static float`	`copySign(float magnitude, float sign)`	返回带有第二个浮点参数符号的第一个浮点参数。
`static double`	`cos(double a)`	返回角度的三角余弦值。
`static double`	`cosh(double x)`	返回 `double`值的双曲余弦值。
`static int`	`decrementExact(int a)`	返回参数递减1，如果结果溢出 `int`则抛出异常。
`static long`	`decrementExact(long a)`	返回参数递减1，如果结果溢出 `long`则抛出异常。
`static double`	`exp(double a)`	返回Euler的数字 e ，其值 `double`值。
`static double`	`expm1(double x)`	返回 e ^x -1。
`static double`	`floor(double a)`	返回小于或等于参数且等于数学整数的最大值（最接近正无穷大） `double` 。
`static int`	`floorDiv(int x, int y)`	返回小于或等于代数商的最大值（最接近正无穷大） `int` 。
`static long`	`floorDiv(long x, int y)`	返回小于或等于代数商的最大值（最接近正无穷大） `long` 。
`static long`	`floorDiv(long x, long y)`	返回小于或等于代数商的最大值（最接近正无穷大） `long` 。
`static int`	`floorMod(int x, int y)`	返回 `int`参数的floor模数。
`static int`	`floorMod(long x, int y)`	返回 `long`和 `int`参数的floor数。
`static long`	`floorMod(long x, long y)`	返回 `long`参数的floor模数。
`static double`	`fma(double a, double b, double c)`	返回三个参数的融合乘法加法; 也就是说，返回与第三个参数相加的前两个参数的精确乘积，然后舍入一次到最接近的`double` 。
`static float`	`fma(float a, float b, float c)`	返回三个参数的融合乘法加法; 也就是说，返回与第三个参数相加的前两个参数的精确乘积，然后舍入一次到最接近的`float` 。
`static int`	`getExponent(double d)`	返回 `double`表示中使用的无偏指数。
`static int`	`getExponent(float f)`	返回 `float`表示中使用的无偏指数。
`static double`	`hypot(double x, double y)`	返回sqrt（ x ² + y ² ），没有中间溢出或下溢。
`static double`	`IEEEremainder(double f1, double f2)`	根据IEEE 754标准规定，计算两个参数的余数运算。
`static int`	`incrementExact(int a)`	返回以1递增的参数，如果结果溢出 `int`则抛出异常。
`static long`	`incrementExact(long a)`	返回以1递增的参数，如果结果溢出 `long`则抛出异常。
`static double`	`log(double a)`	返回 `double`值的自然对数（基数 e ）。
`static double`	`log10(double a)`	返回 `double`值的基数10对数。
`static double`	`log1p(double x)`	返回参数和的总和的自然对数。
`static double`	`max(double a, double b)`	返回两个 `double`值中较大的 `double` 。
`static float`	`max(float a, float b)`	返回两个 `float`值中较大的 `float` 。
`static int`	`max(int a, int b)`	返回两个 `int`值中较大的 `int` 。
`static long`	`max(long a, long b)`	返回两个 `long`值中较大的 `long` 。
`static double`	`min(double a, double b)`	返回两个 `double`值中较小的 `double` 。
`static float`	`min(float a, float b)`	返回两个 `float`值中较小的 `float` 。
`static int`	`min(int a, int b)`	返回两个 `int`值中较小的 `int` 。
`static long`	`min(long a, long b)`	返回两个 `long`值中较小的 `long` 。
`static int`	`multiplyExact(int x, int y)`	返回参数的乘积，如果结果溢出 `int`则抛出异常。
`static long`	`multiplyExact(long x, int y)`	返回参数的乘积，如果结果溢出 `long`则抛出异常。
`static long`	`multiplyExact(long x, long y)`	返回参数的乘积，如果结果溢出 `long`则抛出异常。
`static long`	`multiplyFull(int x, int y)`	返回参数的确切数学乘积。
`static long`	`multiplyHigh(long x, long y)`	返回 `long`作为两个64位因子的128位乘积的最高64位。
`static int`	`negateExact(int a)`	返回参数的否定，如果结果溢出 `int`则抛出异常。
`static long`	`negateExact(long a)`	返回参数的否定，如果结果溢出 `long`则抛出异常。
`static double`	`nextAfter(double start, double direction)`	返回第二个参数方向上第一个参数旁边的浮点数。
`static float`	`nextAfter(float start, double direction)`	返回第二个参数方向上第一个参数旁边的浮点数。
`static double`	`nextDown(double d)`	返回负无穷大方向上与 `d`相邻的浮点值。
`static float`	`nextDown(float f)`	返回负无穷大方向上与 `f`相邻的浮点值。
`static double`	`nextUp(double d)`	返回正无穷大方向上与 `d`相邻的浮点值。
`static float`	`nextUp(float f)`	返回正无穷大方向上与 `f`相邻的浮点值。
`static double`	`pow(double a, double b)`	返回第一个参数的值，该值是第二个参数的幂。
`static double`	`random()`	返回带有正号的 `double`值，大于或等于 `0.0`且小于 `1.0` 。
`static double`	`rint(double a)`	返回与 `double`值最接近的 `double`值，该值等于数学整数。
`static long`	`round(double a)`	返回与参数最接近的 `long` ，并将关系四舍五入为正无穷大。
`static int`	`round(float a)`	返回与参数最接近的 `int` ，并将关系四舍五入为正无穷大。
`static double`	`scalb(double d, int scaleFactor)`	返回 `d` ×2 ^scaleFactor舍入，就像通过单个正确舍入的浮点乘以双 ^scaleFactor值集的成员一样。
`static float`	`scalb(float f, int scaleFactor)`	返回 `f` ×2 ^scaleFactor舍入，就像通过单个正确舍入的浮点乘以浮点值集的成员一样。
`static double`	`signum(double d)`	返回参数的signum函数; 如果参数为零，则为零;如果参数大于零，则为1.0;如果参数小于零，则为-1.0。
`static float`	`signum(float f)`	返回参数的signum函数; 如果参数为零则为零，如果参数大于零则为1.0f，如果参数小于零则为-1.0f。
`static double`	`sin(double a)`	返回角度的三角正弦值。
`static double`	`sinh(double x)`	返回 `double`值的双曲正弦值。
`static double`	`sqrt(double a)`	返回 `double`值的正确舍入正平方根。
`static int`	`subtractExact(int x, int y)`	返回参数的差异，如果结果溢出 `int`则抛出异常。
`static long`	`subtractExact(long x, long y)`	返回参数的差异，如果结果溢出 `long`则抛出异常。
`static double`	`tan(double a)`	返回角度的三角正切。
`static double`	`tanh(double x)`	返回 `double`值的双曲正切值。
`static double`	`toDegrees(double angrad)`	将以弧度测量的角度转换为以度为单位测量的近似等效角度。
`static int`	`toIntExact(long value)`	返回`long`参数的值; 如果值溢出`int`则抛出异常。
`static double`	`toRadians(double angdeg)`	将以度为单位测量的角度转换为以弧度为单位测量的近似等效角度。
`static double`	`ulp(double d)`	返回参数的ulp大小。
`static float`	`ulp(float f)`	返回参数的ulp大小。

声明方法的类 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细信息
  - E
```
public static final double E
```
    double值比任何其他值更接近 e ，即自然对数的基数。
    
    另请参见：
    
    常数字段值
  - PI
```
public static final double PI
```
    double值比任何其他 pi更接近，圆的圆周与其直径的比率。
    
    另请参见：
    
    常数字段值
- 方法详细信息
  - sin
```
public static double sin(double a)
```
    返回角度的三角正弦值。特别案例：
    
    如果参数是NaN或无穷大，则结果为NaN。
    
    如果参数为零，则结果为零，其参数符号相同。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 角度，以弧度表示。
    
    结果
    
    论证的正弦。
  - cos
```
public static double cos(double a)
```
    返回角度的三角余弦值。特别案例：
    
    如果参数是NaN或无穷大，则结果为NaN。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 角度，以弧度表示。
    
    结果
    
    论证的余弦。
  - tan
```
public static double tan(double a)
```
    返回角度的三角正切。特别案例：
    
    如果参数是NaN或无穷大，则结果为NaN。
    
    如果参数为零，则结果为零，其参数符号相同。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 角度，以弧度表示。
    
    结果
    
    参数的正切。
  - asin
```
public static double asin(double a)
```
    返回值的反正弦值; 返回的角度在-pi / 2到pi / 2的范围内。特别案例：
    
    如果参数为NaN或其绝对值大于1，则结果为NaN。
    
    如果参数为零，则结果为零，其参数符号相同。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 要返回其正弦值的值。
    
    结果
    
    论证的反正弦。
  - acos
```
public static double acos(double a)
```
    返回值的反余弦值; 返回的角度在0.0到pi的范围内。特殊情况：
    
    如果参数为NaN或其绝对值大于1，则结果为NaN。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 要返回其余弦余弦的值。
    
    结果
    
    参数的反余弦。
  - atan
```
public static double atan(double a)
```
    返回值的反正切值; 返回的角度在-pi / 2到pi / 2的范围内。特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为零，则结果为零，其参数符号相同。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 要返回其反正切值的值。
    
    结果
    
    参数的反正切。
  - toRadians
```
public static double toRadians(double angdeg)
```
    将以度为单位测量的角度转换为以弧度为单位测量的近似等效角度。从度数到弧度的转换通常是不精确的。
    
    参数
    
    angdeg - 角度，以度为单位
    
    结果
    
    以弧度为单位测量角度 angdeg 。
    
    从以下版本开始：
    
    1.2
  - toDegrees
```
public static double toDegrees(double angrad)
```
    将以弧度测量的角度转换为以度为单位测量的近似等效角度。从弧度到度数的转换通常是不精确的; 用户不应该指望cos(toRadians(90.0))恰好等于0.0 。
    
    参数
    
    angrad - 角度，以弧度表示
    
    结果
    
    以度为单位测量角度 angrad 。
    
    从以下版本开始：
    
    1.2
  - exp
```
public static double exp(double a)
```
    返回Euler的数字e ， double值的double 。特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数是正无穷大，那么结果是正无穷大。
    
    如果参数为负无穷大，则结果为正零。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 将 e提升到的指数。
    
    结果
    
    值 e ^a ，其中 e是自然对数的基数。
  - log
```
public static double log(double a)
```
    返回double值的自然对数（基数e ）。特别案例：
    
    如果参数为NaN或小于零，则结果为NaN。
    
    如果参数是正无穷大，那么结果是正无穷大。
    
    如果参数为正零或负零，则结果为负无穷大。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 一个值
    
    结果
    
    值ln a ，自然对数为 a 。
  - log10
```
public static double log10(double a)
```
    返回double值的基数10对数。特别案例：
    
    如果参数为NaN或小于零，则结果为NaN。
    
    如果参数是正无穷大，那么结果是正无穷大。
    
    如果参数为正零或负零，则结果为负无穷大。
    
    如果参数等于10 ^n，用于整数n，则结果为n。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 一个值
    
    结果
    
    基数为10的对数为 a 。
    
    从以下版本开始：
    
    1.5
  - sqrt
```
public static double sqrt(double a)
```
    返回double值的正确舍入的正平方根。特别案例：
    
    如果参数为NaN或小于零，则结果为NaN。
    
    如果参数是正无穷大，那么结果是正无穷大。
    
    如果参数为正零或负零，则结果与参数相同。
    
    否则，结果是最接近参数值的真数学平方根的double值。
    参数
    
    a - 一个值。
    
    结果
    
    正方根a 。如果参数为NaN或小于零，则结果为NaN。
  - cbrt
```
public static double cbrt(double a)
```
    返回double值的多维数据集根。对于正有限x ， cbrt(-x) == -cbrt(x) ; 也就是说，负值的立方根是该值的大小的立方根的负数。特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数是无穷大，则结果是无穷大，其符号与参数相同。
    
    如果参数为零，则结果为零，其参数符号相同。
    
    计算结果必须在精确结果的1 ulp范围内。
    参数
    
    a - 一个值。
    
    结果
    
    a 。
    
    从以下版本开始：
    
    1.5
  - IEEEremainder
```
public static double IEEEremainder(double f1,                                   double f2)
```
    根据IEEE 754标准规定，计算两个参数的余数运算。余数的算术值等于f1 - f2 A-n，其中n是最接近商的精确算术值的数学整数f1/f2 ，并且如果两个整数都同样接近f1/f2 ，那么n是其中的偶数。如果余数为零，则其符号与第一个参数的符号相同。特别案例：
    
    如果任一参数为NaN，或者第一个参数为无穷大，或者第二个参数为正零或负零，则结果为NaN。
    
    如果第一个参数是有限的，第二个参数是无限的，那么结果与第一个参数相同。
    参数
    
    f1 - 股息。
    
    f2 - 除数
    
    结果
    
    当 f1除以 f2时的余数。
  - ceil
```
public static double ceil(double a)
```
    返回大于或等于参数且等于数学整数的最小（最接近负无穷大） double值。特别案例：
    
    如果参数值已经等于数学整数，则结果与参数相同。
    
    如果参数为NaN或无穷大或正零或负零，则结果与参数相同。
    
    如果参数值小于零但大于-1.0，则结果为负零。
    
    需要注意的是价值Math.ceil(x)正是价值-Math.floor(-x) 。
    参数
    
    a - 一个值。
    
    结果
    
    最小（最接近负无穷大）浮点值，该值大于或等于参数且等于数学整数。
  - floor
```
public static double floor(double a)
```
    返回小于或等于参数且等于数学整数的最大值（最接近正无穷大） double 。特别案例：
    
    如果参数值已经等于数学整数，则结果与参数相同。
    
    如果参数为NaN或无穷大或正零或负零，则结果与参数相同。
    参数
    
    a - 一个值。
    
    结果
    
    最大（最接近正无穷大）浮点值，小于或等于参数且等于数学整数。
  - rint
```
public static double rint(double a)
```
    返回与double值最接近的double值，该值等于数学整数。如果两个double是数学整数的值同样接近，则结果是偶数的整数值。特别案例：
    
    如果参数值已经等于数学整数，则结果与参数相同。
    
    如果参数为NaN或无穷大或正零或负零，则结果与参数相同。
    参数
    
    a - 值 double 。
    
    结果
    
    最接近 a浮点值，等于数学整数。
  - atan2
```
public static double atan2(double y,                           double x)
```
    返回从直角坐标（转换角度theta x ， y ）为极坐标（R，θ-）。 该方法通过计算-π到pi的范围内的y/x反正切来计算相位θ 。特别案例：
    
    如果任一参数是NaN，则结果为NaN。
    
    如果第一个参数为正零且第二个参数为正，或者第一个参数为正且有限且第二个参数为正无穷大，则结果为正零。
    
    如果第一个参数为负零且第二个参数为正，或者第一个参数为负且有限且第二个参数为正无穷大，则结果为负零。
    
    如果第一个参数为正零且第二个参数为负，或者第一个参数为正且有限且第二个参数为负无穷大，则结果为最接近pi的double值。
    
    如果第一个参数是负零，第二个参数是负的，或者第一参数是负的有限值，第二个参数是负无穷大，那么结果是double值最接近- PI。
    
    如果第一个参数为正且第二个参数为正零或负零，或者第一个参数为正无穷大且第二个参数为有限，则结果为最接近pi / 2的double值。
    
    如果第一个参数是负的，第二个参数是正的零或负零，或者第一参数是负无穷大，并且第二个参数是有限的，那么结果是double最接近的值到- PI / 2。
    
    如果两个参数都是正无穷大，则结果是最接近pi / 4的double值。
    
    如果第一个参数是正无穷大而第二个参数是负无穷大，则结果是最接近3 * pi / 4的double值。
    
    如果第一个参数是负无穷大，第二个参数是正无穷大，那么结果是double最接近的值到- PI / 4。
    
    如果两个参数均为负无穷大，则结果是最接近-3 * pi / 4的double值。
    
    计算结果必须在精确结果的2 ulps范围内。结果必须是半单调的。
    参数
    
    y - 纵坐标
    
    x - 横坐标
    
    结果
    
    极坐标中点（ r ， theta ）的 θ分量，对应于笛卡尔坐标系中的点（ x ， y ）。
  - pow
```
public static double pow(double a,                         double b)
```
    返回第一个参数的值，该值是第二个参数的幂。特别案例：
    
    如果第二个参数为正或负零，则结果为1.0。
    
    如果第二个参数是1.0，则结果与第一个参数相同。
    
    如果第二个参数是NaN，则结果为NaN。
    
    如果第一个参数是NaN而第二个参数是非零，那么结果是NaN。
    
    如果
    
    第一个参数的绝对值大于1，第二个参数是正无穷大，或
    
    第一个参数的绝对值小于1，第二个参数为负无穷大，
    
    然后结果是正无穷大。
    
    如果
    
    第一个参数的绝对值大于1，第二个参数是负无穷大，或
    
    第一个参数的绝对值小于1，第二个参数是正无穷大，
    
    那么结果是正零。
    
    如果第一个参数的绝对值等于1而第二个参数是无穷大，则结果为NaN。
    
    如果
    
    第一个参数是正零，第二个参数大于零，或者
    
    第一个参数是正无穷大，第二个参数小于零，
    
    那么结果是正零。
    
    如果
    
    第一个参数是正零，第二个参数小于零，或者
    
    第一个参数是正无穷大，第二个参数大于零，
    
    然后结果是正无穷大。
    
    如果
    
    第一个参数是负零，第二个参数大于零但不是有限的奇数，或者
    
    第一个参数是负无穷大，第二个参数小于零但不是有限的奇数，
    
    那么结果是正零。
    
    如果
    
    第一个参数是负零，第二个参数是正有限奇数，或
    
    第一个参数是负无穷大，第二个参数是负有限奇数，
    
    然后结果是负零。
    
    如果
    
    第一个参数是负零，第二个参数小于零但不是有限的奇数，或者
    
    第一个参数是负无穷大，第二个参数大于零但不是有限的奇数，
    
    然后结果是正无穷大。
    
    如果
    
    第一个参数是负零，第二个参数是负有限奇数，或
    
    第一个参数是负无穷大，第二个参数是正有限奇数，
    
    然后结果是负无穷大。
    
    如果第一个参数是有限的且小于零
    
    如果第二个参数是有限偶数，则结果等于将第一个参数的绝对值提高到第二个参数的幂的结果
    
    如果第二个参数是有限的奇数，则结果等于将第一个参数的绝对值提高到第二个参数的幂的结果的负数
    
    如果第二个参数是有限的而不是整数，则结果为NaN。
    
    如果两个参数都是整数，那么结果完全等于将第一个参数提升到第二个参数的幂的数学结果，如果该结果实际上可以完全表示为double值。
    
    （在前述的说明中，一个浮点值被认为是一个整数，当且仅当它是有限的，并且该方法的一个固定点ceil ，或等价地，该方法的一个固定点floor 。的值是一个固定的点当且仅当将该方法应用于该值的结果等于该值时，单参数方法。）
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    a - 基地。
    
    b - 指数。
    
    结果
    
    值 a ^b 。
  - round
```
public static int round(float a)
```
    返回与参数最接近的int ，其中四度为正无穷大。
    特别案例：
    
    如果参数为NaN，则结果为0。
    
    如果参数为负无穷大或任何小于或等于Integer.MIN_VALUE的值，则结果等于Integer.MIN_VALUE的值。
    
    如果参数为正无穷大或任何大于或等于Integer.MAX_VALUE的值，则结果等于Integer.MAX_VALUE的值。
    参数
    
    a - 要舍入为整数的浮点值。
    
    结果
    
    参数的值四舍五入到最接近的 int值。
    
    另请参见：
    
    Integer.MAX_VALUE ， Integer.MIN_VALUE
  - round
```
public static long round(double a)
```
    返回与参数最接近的long ，其中四度为正无穷大。
    特别案例：
    
    如果参数为NaN，则结果为0。
    
    如果参数为负无穷大或任何小于或等于Long.MIN_VALUE的值，则结果等于Long.MIN_VALUE的值。
    
    如果参数为正无穷大或任何大于或等于Long.MAX_VALUE的值，则结果等于Long.MAX_VALUE的值。
    参数
    
    a - 要舍入为 long的浮点值。
    
    结果
    
    参数的值四舍五入到最接近的 long值。
    
    另请参见：
    
    Long.MAX_VALUE ， Long.MIN_VALUE
  - random
```
public static double random()
```
    返回带有正号的double值，大于或等于0.0且小于1.0 。从该范围（当然）均匀分布伪随机地选择返回值。
    首次调用此方法时，它会创建一个新的伪随机数生成器，就像表达式一样
    
    new java.util.Random()
    此后，此新伪随机数生成器用于对此方法的所有调用，并且在其他任何地方都不使用。
    此方法已正确同步，以允许多个线程正确使用。但是，如果许多线程需要以很高的速率生成伪随机数，则可以减少每个线程拥有自己的伪随机数生成器的争用。
    API Note:
    
    由于最大double值小于1.0为Math.nextDown(1.0) ，值x在收盘区间[x1,x2]其中x1<=x2可由报表定义
    
    double f = Math.random()/Math.nextDown(1.0); double x = x1*(1.0 - f) + x2*f;
    
    结果
    
    伪随机数 double大于或等于 0.0且小于 1.0 。
    
    另请参见：
    
    nextDown(double) ， Random.nextDouble()
  - addExact
```
public static int addExact(int x,                           int y)
```
    返回其参数的总和，如果结果溢出 int则抛出异常。
    
    参数
    
    x - 第一个值
    
    y - 第二个值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出int
    
    从以下版本开始：
    
    1.8
  - addExact
```
public static long addExact(long x,                            long y)
```
    返回其参数的总和，如果结果溢出 long则抛出异常。
    
    参数
    
    x - 第一个值
    
    y - 第二个值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出很长时间
    
    从以下版本开始：
    
    1.8
  - subtractExact
```
public static int subtractExact(int x,                                int y)
```
    返回参数的差异，如果结果溢出 int则抛出异常。
    
    参数
    
    x - 第一个值
    
    y - 从第一个值中减去的第二个值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出int
    
    从以下版本开始：
    
    1.8
  - subtractExact
```
public static long subtractExact(long x,                                 long y)
```
    返回参数的差异，如果结果溢出 long则抛出异常。
    
    参数
    
    x - 第一个值
    
    y - 从第一个值中减去的第二个值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出很长时间
    
    从以下版本开始：
    
    1.8
  - multiplyExact
```
public static int multiplyExact(int x,                                int y)
```
    返回参数的乘积，如果结果溢出 int则抛出异常。
    
    参数
    
    x - 第一个值
    
    y - 第二个值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出int
    
    从以下版本开始：
    
    1.8
  - multiplyExact
```
public static long multiplyExact(long x,                                 int y)
```
    返回参数的乘积，如果结果溢出 long则抛出异常。
    
    参数
    
    x - 第一个值
    
    y - 第二个值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出很长时间
    
    从以下版本开始：
    
    9
  - multiplyExact
```
public static long multiplyExact(long x,                                 long y)
```
    返回参数的乘积，如果结果溢出 long则抛出异常。
    
    参数
    
    x - 第一个值
    
    y - 第二个值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出很长时间
    
    从以下版本开始：
    
    1.8
  - incrementExact
```
public static int incrementExact(int a)
```
    返回以1递增的参数，如果结果溢出 int则抛出异常。
    
    参数
    
    a - 要递增的值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出int
    
    从以下版本开始：
    
    1.8
  - incrementExact
```
public static long incrementExact(long a)
```
    返回以1递增的参数，如果结果溢出 long则抛出异常。
    
    参数
    
    a - 要递增的值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出很长时间
    
    从以下版本开始：
    
    1.8
  - decrementExact
```
public static int decrementExact(int a)
```
    返回参数递减1，如果结果溢出 int则抛出异常。
    
    参数
    
    a - 要减少的值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出int
    
    从以下版本开始：
    
    1.8
  - decrementExact
```
public static long decrementExact(long a)
```
    返回参数递减1，如果结果溢出 long则抛出异常。
    
    参数
    
    a - 要减少的值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出很长时间
    
    从以下版本开始：
    
    1.8
  - negateExact
```
public static int negateExact(int a)
```
    返回参数的否定，如果结果溢出 int则抛出异常。
    
    参数
    
    a - 否定的价值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出int
    
    从以下版本开始：
    
    1.8
  - negateExact
```
public static long negateExact(long a)
```
    返回参数的否定，如果结果溢出 long则抛出异常。
    
    参数
    
    a - 要否定的值
    
    结果
    
    结果
    
    异常
    
    ArithmeticException - 如果结果溢出很长时间
    
    从以下版本开始：
    
    1.8
  - toIntExact
```
public static int toIntExact(long value)
```
    返回long参数的值; 如果值溢出int则抛出异常。
    
    参数
    
    value - 长值
    
    结果
    
    参数为int
    
    异常
    
    ArithmeticException - 如果 argument溢出一个int
    
    从以下版本开始：
    
    1.8
  - multiplyFull
```
public static long multiplyFull(int x,                                int y)
```
    返回参数的确切数学乘积。
    
    参数
    
    x - 第一个值
    
    y - 第二个值
    
    结果
    
    结果
    
    从以下版本开始：
    
    9
  - multiplyHigh
```
public static long multiplyHigh(long x,                                long y)
```
    返回 long作为两个64位因子的128位乘积的最高64位。
    
    参数
    
    x - 第一个值
    
    y - 第二个值
    
    结果
    
    结果
    
    从以下版本开始：
    
    9
  - floorDiv
```
public static int floorDiv(int x,                           int y)
```
    返回小于或等于代数商的最大值（最接近正无穷大） int 。有一种特殊情况，如果被除数是Integer.MIN_VALUE且除数是-1 ，则发生整数溢出，结果等于Integer.MIN_VALUE 。
    正整数除法在舍入到零舍入模式（截断）下操作。相反，该操作在朝向负无穷大（地板）舍入模式的轮次下起作用。当精确结果为负时，地板舍入模式会提供截断的不同结果。
    
    如果参数的符号相同，则floorDiv和/运算符的结果相同。
    例如， floorDiv(4, 3) == 1和(4 / 3) == 1 。
    
    如果参数的符号不同，则商为负， floorDiv返回小于或等于商的整数， /运算符返回最接近零的整数。
    例如， floorDiv(-4, 3) == -2 ，而(-4 / 3) == -1 。
    参数
    
    x - 股息
    
    y - 除数
    
    结果
    
    最大（最接近正无穷大） int值小于或等于代数商。
    
    异常
    
    ArithmeticException - 如果除数 y为零
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    floorMod(int, int) ， floor(double)
  - floorDiv
```
public static long floorDiv(long x,                            int y)
```
    返回小于或等于代数商的最大值（最接近正无穷大） long 。有一种特殊情况，如果被除数是Long.MIN_VALUE且除数是-1 ，则发生整数溢出，结果等于Long.MIN_VALUE 。
    正整数除法在舍入到零舍入模式（截断）下操作。相反，该操作在朝向负无穷大（地板）舍入模式的轮次下起作用。当精确结果为负时，地板舍入模式会提供截断的不同结果。
    
    有关示例，请参阅floorDiv(int, int) 。
    
    参数
    
    x - 股息
    
    y - 除数
    
    结果
    
    最大（最接近正无穷大） int值小于或等于代数商。
    
    异常
    
    ArithmeticException - 如果除数 y为零
    
    从以下版本开始：
    
    9
    
    另请参见：
    
    floorMod(long, int) ， floor(double)
  - floorDiv
```
public static long floorDiv(long x,                            long y)
```
    返回小于或等于代数商的最大值（最接近正无穷大） long 。有一种特殊情况，如果被除数是Long.MIN_VALUE且除数是-1 ，则发生整数溢出，结果等于Long.MIN_VALUE 。
    正整数除法在舍入到零舍入模式（截断）下操作。相反，该操作在朝向负无穷大（地板）舍入模式的轮次下起作用。当精确结果为负时，地板舍入模式会提供截断的不同结果。
    
    有关示例，请参阅floorDiv(int, int) 。
    
    参数
    
    x - 股息
    
    y - 除数
    
    结果
    
    最大（最接近正无穷大） long值小于或等于代数商。
    
    异常
    
    ArithmeticException - 如果除数 y为零
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    floorMod(long, long) ， floor(double)
  - floorMod
```
public static int floorMod(int x,                           int y)
```
    返回int参数的floor模数。
    地板模数为x - (floorDiv(x, y) * y) ，与除数y具有相同的符号，并且在-abs(y) < r < +abs(y)的范围内。
    
    floorDiv和floorMod之间的关系floorDiv ：
    
    floorDiv(x, y) * y + floorMod(x, y) == x
    
    在之间的值的差floorMod和%操作者是由于之间的差floorDiv返回小于或等于商和整数/操作者返回最接近零的整数。
    
    例子：
    
    如果参数的符号相同，则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
    
    如果参数的符号未知且需要正模数，则可以计算为(floorMod(x, y) + abs(y)) % abs(y) 。
    参数
    
    x - 股息
    
    y - 除数
    
    结果
    
    地板模数 x - (floorDiv(x, y) * y)
    
    异常
    
    ArithmeticException - 如果除数 y为零
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    floorDiv(int, int)
  - floorMod
```
public static int floorMod(long x,                           int y)
```
    返回long和int参数的楼面模数。
    地板模数为x - (floorDiv(x, y) * y) ，与除数y具有相同的符号，并且在-abs(y) < r < +abs(y)的范围内。
    
    floorDiv和floorMod之间的关系floorDiv ：
    
    floorDiv(x, y) * y + floorMod(x, y) == x
    
    有关示例，请参阅floorMod(int, int) 。
    参数
    
    x - 股息
    
    y - 除数
    
    结果
    
    地板模数 x - (floorDiv(x, y) * y)
    
    异常
    
    ArithmeticException - 如果除数 y为零
    
    从以下版本开始：
    
    9
    
    另请参见：
    
    floorDiv(long, int)
  - floorMod
```
public static long floorMod(long x,                            long y)
```
    返回long参数的floor模数。
    地板模数为x - (floorDiv(x, y) * y) ，与除数y具有相同的符号，并且在-abs(y) < r < +abs(y)的范围内。
    
    floorDiv和floorMod之间的关系floorDiv ：
    
    floorDiv(x, y) * y + floorMod(x, y) == x
    
    有关示例，请参阅floorMod(int, int) 。
    参数
    
    x - 股息
    
    y - 除数
    
    结果
    
    地板模数 x - (floorDiv(x, y) * y)
    
    异常
    
    ArithmeticException - 如果除数 y为零
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    floorDiv(long, long)
  - abs
```
public static int abs(int a)
```
    返回int值的绝对值。如果参数不是负数，则返回参数。如果参数为负数，则返回参数的否定。
    注意，如果参数等于值Integer.MIN_VALUE ，最负表示的int值，结果是相同的值，且为负。
    
    参数
    
    a - 要确定其绝对值的参数
    
    结果
    
    参数的绝对值。
  - abs
```
public static long abs(long a)
```
    返回long值的绝对值。如果参数不是负数，则返回参数。如果参数为负数，则返回参数的否定。
    请注意，如果参数等于值Long.MIN_VALUE ，最负值可表示的值long ，则结果为相同值，即负值。
    
    参数
    
    a - 要确定其绝对值的参数
    
    结果
    
    参数的绝对值。
  - abs
```
public static float abs(float a)
```
    返回float值的绝对值。如果参数不是负数，则返回参数。如果参数为负数，则返回参数的否定。特别案例：
    
    如果参数为正零或负零，则结果为正零。
    
    如果参数是无限的，则结果是正无穷大。
    
    如果参数是NaN，则结果为NaN。
    API Note:
    
    如上所述，此方法的一个有效实现由下面的表达式给出，该表达式计算具有与参数相同的指数和有效数的 float ，但保证零符号位指示正值：
    Float.intBitsToFloat(0x7fffffff & Float.floatToRawIntBits(a))
    
    参数
    
    a - 要确定其绝对值的参数
    
    结果
    
    参数的绝对值。
  - abs
```
public static double abs(double a)
```
    返回double值的绝对值。如果参数不是负数，则返回参数。如果参数为负数，则返回参数的否定。特别案例：
    
    如果参数为正零或负零，则结果为正零。
    
    如果参数是无限的，则结果是正无穷大。
    
    如果参数是NaN，则结果为NaN。
    API Note:
    
    如上所述，此方法的一个有效实现由下面的表达式给出，该表达式计算具有与参数相同的指数和有效数的 double ，但保证零符号位指示正值：
    Double.longBitsToDouble((Double.doubleToRawLongBits(a)<<1)>>>1)
    
    参数
    
    a - 要确定其绝对值的参数
    
    结果
    
    参数的绝对值。
  - max
```
public static int max(int a,                      int b)
```
    返回两个int值中较大的int 。也就是说，结果是参数更接近Integer.MAX_VALUE的值。如果参数具有相同的值，则结果是相同的值。
    
    参数
    
    a - 一个论点。
    
    b - 另一个论点。
    
    结果
    
    较大的 a和 b 。
  - max
```
public static long max(long a,                       long b)
```
    返回两个long值中较大的long 。也就是说，结果是参数更接近Long.MAX_VALUE的值。如果参数具有相同的值，则结果是相同的值。
    
    参数
    
    a - 一个论点。
    
    b - 另一个论点。
    
    结果
    
    较大的 a和 b 。
  - max
```
public static float max(float a,                        float b)
```
    返回两个float值中较大的float 。也就是说，结果是更接近正无穷大的论证。如果参数具有相同的值，则结果是相同的值。如果任一值为NaN，则结果为NaN。与数值比较运算符不同，此方法将负零视为严格小于正零。如果一个参数为正零而另一个参数为负零，则结果为正零。
    
    参数
    
    a - 一个论点。
    
    b - 另一个论点。
    
    结果
    
    较大的 a和 b 。
  - max
```
public static double max(double a,                         double b)
```
    返回两个double值中较大的double 。也就是说，结果是更接近正无穷大的论证。如果参数具有相同的值，则结果是相同的值。如果任一值为NaN，则结果为NaN。与数值比较运算符不同，此方法将负零视为严格小于正零。如果一个参数为正零而另一个参数为负零，则结果为正零。
    
    参数
    
    a - 一个论点。
    
    b - 另一个论点。
    
    结果
    
    较大的 a和 b 。
  - min
```
public static int min(int a,                      int b)
```
    返回两个int值中较小的int 。也就是说，结果参数更接近Integer.MIN_VALUE的值。如果参数具有相同的值，则结果是相同的值。
    
    参数
    
    a - 一个论点。
    
    b - 另一个论点。
    
    结果
    
    较小的 a和 b 。
  - min
```
public static long min(long a,                       long b)
```
    返回两个long值中较小的long 。也就是说，结果是参数更接近Long.MIN_VALUE的值。如果参数具有相同的值，则结果是相同的值。
    
    参数
    
    a - 一个参数。
    
    b - 另一个论点。
    
    结果
    
    较小的 a和 b 。
  - min
```
public static float min(float a,                        float b)
```
    返回两个float值中较小的float 。也就是说，结果是值更接近负无穷大。如果参数具有相同的值，则结果是相同的值。如果任一值为NaN，则结果为NaN。与数值比较运算符不同，此方法将负零视为严格小于正零。如果一个参数为正零而另一个参数为负零，则结果为负零。
    
    参数
    
    a - 一个论点。
    
    b - 另一个论点。
    
    结果
    
    较小的 a和 b 。
  - min
```
public static double min(double a,                         double b)
```
    返回两个double值中较小的double 。也就是说，结果是值更接近负无穷大。如果参数具有相同的值，则结果是相同的值。如果任一值为NaN，则结果为NaN。与数值比较运算符不同，此方法将负零视为严格小于正零。如果一个参数为正零而另一个参数为负零，则结果为负零。
    
    参数
    
    a - 一个论点。
    
    b - 另一个论点。
    
    结果
    
    较小的 a和 b 。
  - fma
```
public static double fma(double a,                         double b,                         double c)
```
    返回三个参数的融合乘法加法; 也就是说，返回与第三个参数相加的前两个参数的精确乘积，然后舍入一次到最接近的double 。使用round to nearest even rounding mode完成舍入。相反，如果a * b + c被评估为常规浮点表达式，则涉及两个舍入误差，第一个用于乘法运算，第二个用于加法运算。
    特别案例：
    
    如果任何参数是NaN，则结果为NaN。
    
    如果前两个参数中的一个是无穷大而另一个是零，则结果为NaN。
    
    如果前两个参数的确切乘积是无穷大的（换句话说，至少有一个参数是无穷大而另一个既不是零也不是NaN），第三个参数是相反符号的无穷大，结果是NaN。
    
    请注意， fma(a, 1.0, c)返回与（ a + c ）相同的结果。然而， fma(a, b, +0.0) 并不总是返回相同的结果为（ a * b ），因为fma(-0.0, +0.0, +0.0)为+0.0 ，而（ -0.0 * +0.0 ）为-0.0 ; fma(a, b, -0.0)相当于（ a * b ）。
    API Note:
    
    该方法对应于IEEE 754-2008中定义的fusedMultiplyAdd操作。
    
    参数
    
    a - 一个值
    
    b - 一个值
    
    c - 一个值
    
    结果
    
    （A A- B + C）来计算，因为如果具有无限范围和精度，并且一旦四舍五入到最近的 double值
    
    从以下版本开始：
    
    9
  - fma
```
public static float fma(float a,                        float b,                        float c)
```
    返回三个参数的融合乘法加法; 也就是说，返回与第三个参数相加的前两个参数的精确乘积，然后舍入一次到最接近的float 。使用round to nearest even rounding mode完成舍入。相反，如果a * b + c被评估为常规浮点表达式，则涉及两个舍入误差，第一个用于乘法运算，第二个用于加法运算。
    特别案例：
    
    如果任何参数是NaN，则结果为NaN。
    
    如果前两个参数中的一个是无穷大而另一个是零，则结果为NaN。
    
    如果前两个参数的确切乘积是无穷大的（换句话说，至少有一个参数是无穷大而另一个既不是零也不是NaN），第三个参数是相反符号的无穷大，结果是NaN。
    
    请注意， fma(a, 1.0f, c)返回与（ a + c ）相同的结果。然而， fma(a, b, +0.0f) 并不总是返回相同的结果为（ a * b ），因为fma(-0.0f, +0.0f, +0.0f)为+0.0f ，而（ -0.0f * +0.0f ）为-0.0f ; fma(a, b, -0.0f)相当于（ a * b ）。
    API Note:
    
    该方法对应于IEEE 754-2008中定义的fusedMultiplyAdd操作。
    
    参数
    
    a - 一个值
    
    b - 一个值
    
    c - 一个值
    
    结果
    
    （A A- B + C）来计算，因为如果具有无限范围和精度，并且一旦四舍五入到最近的 float值
    
    从以下版本开始：
    
    9
  - ulp
```
public static double ulp(double d)
```
    返回参数的ulp大小。 double值的最后一个单位的ulp单位是此浮点值与double值之间的正距离，其值大小更大。注意，对于非NaN x ， ulp(-x) == ulp(x) 。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为正或负无穷大，则结果为正无穷大。
    
    如果参数为正或负零，则结果为Double.MIN_VALUE 。
    
    如果参数是± Double.MAX_VALUE ，则结果等于2 ⁹⁷¹ 。
    参数
    
    d - 要返回其ulp的浮点值
    
    结果
    
    参数的ulp的大小
    
    从以下版本开始：
    
    1.5
  - ulp
```
public static float ulp(float f)
```
    返回参数的ulp大小。最后一个位置为float的ulp单位是此浮点值与float值之间的正距离，其值大小更大。注意，对于非NaN x ， ulp(-x) == ulp(x) 。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为正或负无穷大，则结果为正无穷大。
    
    如果参数为正或负零，则结果为Float.MIN_VALUE 。
    
    如果参数是± Float.MAX_VALUE ，则结果等于2 ¹⁰⁴ 。
    参数
    
    f - 要返回其ulp的浮点值
    
    结果
    
    参数的ulp的大小
    
    从以下版本开始：
    
    1.5
  - signum
```
public static double signum(double d)
```
    返回参数的signum函数; 如果参数为零，则为零;如果参数大于零，则为1.0;如果参数小于零，则为-1.0。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为正零或负零，则结果与参数相同。
    参数
    
    d - 要返回其signum的浮点值
    
    结果
    
    参数的signum函数
    
    从以下版本开始：
    
    1.5
  - signum
```
public static float signum(float f)
```
    返回参数的signum函数; 如果参数为零则为零，如果参数大于零则为1.0f，如果参数小于零则为-1.0f。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为正零或负零，则结果与参数相同。
    参数
    
    f - 要返回其signum的浮点值
    
    结果
    
    参数的signum函数
    
    从以下版本开始：
    
    1.5
  - sinh
```
public static double sinh(double x)
```
    返回double值的双曲正弦值。 x的双曲正弦定义为（ e ^x -e ^-x ）/ 2，其中e是Euler's number 。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数是无穷大，则结果是无穷大，其符号与参数相同。
    
    如果参数为零，则结果为零，其参数符号相同。
    
    计算结果必须在精确结果的2.5 ulps范围内。
    参数
    
    x - 要返回双曲正弦的数字。
    
    结果
    
    双曲正弦 x 。
    
    从以下版本开始：
    
    1.5
  - cosh
```
public static double cosh(double x)
```
    返回double值的双曲余弦值。 x的双曲余弦定义为（ e ^x + e ^-x ）/ 2，其中e是Euler's number 。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数是无穷大的，那么结果就是正无穷大。
    
    如果参数为零，则结果为1.0 。
    
    计算结果必须在精确结果的2.5 ulps范围内。
    参数
    
    x - 要返回双曲余弦值的数字。
    
    结果
    
    双曲余弦值为 x 。
    
    从以下版本开始：
    
    1.5
  - tanh
```
public static double tanh(double x)
```
    返回double值的双曲正切值。 x的双曲正切定义为（ e ^x -e ^-x ）/（ e ^x + e ^-x ），换句话说， sinh(x) / cosh(x) 。请注意，精确tanh的绝对值始终小于1。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为零，则结果为零，其参数符号相同。
    
    如果参数为正无穷大，则结果为+1.0 。
    
    如果参数为负无穷大，则结果为-1.0 。
    
    计算结果必须在精确结果的2.5 ulps范围内。任何有限输入的tanh的结果必须具有小于或等于1的绝对值。注意，一旦tanh的确切结果在±1的极限值的ulp的1/2内，正确签名Â± 1.0应该退还。
    参数
    
    x - 要返回双曲正切的数字。
    
    结果
    
    双曲正切 x 。
    
    从以下版本开始：
    
    1.5
  - hypot
```
public static double hypot(double x,                           double y)
```
    返回sqrt（ x ² + y ² ），没有中间溢出或下溢。
    特别案例：
    
    如果任一参数是无穷大，则结果为正无穷大。
    
    如果任一参数是NaN且两个参数都不是无穷大，则结果为NaN。
    
    计算结果必须在精确结果的1 ulp范围内。如果一个参数保持不变，则结果必须在另一个参数中是半单调的。
    参数
    
    x - 一个值
    
    y - 一个值
    
    结果
    
    sqrt（ x ² + y ² ）没有中间上溢或下溢
    
    从以下版本开始：
    
    1.5
  - expm1
```
public static double expm1(double x)
```
    返回e ^x -1。请注意，对于接近0的x值， expm1(x) + 1的精确和更接近e ^x的真实结果，而不是exp(x) 。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数是正无穷大，那么结果是正无穷大。
    
    如果参数为负无穷大，则结果为-1.0。
    
    如果参数为零，则结果为零，其参数符号相同。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。任何有限输入的结果expm1必须大于或等于-1.0 。请注意，一旦e ^x - 1的确切结果在极限值-1的1/2 ulp范围内，则应返回-1.0 。
    参数
    
    x - 在计算 e ^x -1时将 e提高到的指数。
    
    结果
    
    值 e ^x - 1。
    
    从以下版本开始：
    
    1.5
  - log1p
```
public static double log1p(double x)
```
    返回参数之和1注的自然对数，对于小值x ，结果log1p(x)更接近LN（1 +的真实结果x ），比的浮点评估log(1.0+x) 。
    特别案例：
    
    如果参数为NaN或小于-1，则结果为NaN。
    
    如果参数是正无穷大，那么结果是正无穷大。
    
    如果参数为负数，则结果为负无穷大。
    
    如果参数为零，则结果为零，其参数符号相同。
    
    计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。
    参数
    
    x - 一个值
    
    结果
    
    值ln（ x + 1），自然日志 x + 1
    
    从以下版本开始：
    
    1.5
  - copySign
```
public static double copySign(double magnitude,                              double sign)
```
    返回带有第二个浮点参数符号的第一个浮点参数。请注意，与StrictMath.copySign方法不同，此方法不要求将NaN sign参数视为正值; 允许实现将一些NaN参数视为肯定，将其他NaN参数视为否定以允许更高的性能。
    
    参数
    
    magnitude - 提供结果大小的参数
    
    sign - 提供结果符号的参数
    
    结果
    
    值为 magnitude且符号为 sign 。
    
    从以下版本开始：
    
    1.6
  - copySign
```
public static float copySign(float magnitude,                             float sign)
```
    返回带有第二个浮点参数符号的第一个浮点参数。请注意，与StrictMath.copySign方法不同，此方法不要求将NaN sign参数视为正值; 允许实现将一些NaN参数视为肯定，将其他NaN参数视为否定以允许更高的性能。
    
    参数
    
    magnitude - 提供结果大小的参数
    
    sign - 提供结果符号的参数
    
    结果
    
    一个值为 magnitude且符号为 sign 。
    
    从以下版本开始：
    
    1.6
  - getExponent
```
public static int getExponent(float f)
```
    返回float表示中使用的无偏指数。特别案例：
    
    如果参数为NaN或无穷大，则结果为Float.MAX_EXPONENT + 1。
    
    如果参数为零或次正规，则结果为Float.MIN_EXPONENT -1。
    参数
    
    f - 值 float
    
    结果
    
    论证的无偏见指数
    
    从以下版本开始：
    
    1.6
  - getExponent
```
public static int getExponent(double d)
```
    返回double表示中使用的无偏指数。特别案例：
    
    如果参数为NaN或无穷大，则结果为Double.MAX_EXPONENT + 1。
    
    如果参数为零或次正规，则结果为Double.MIN_EXPONENT -1。
    参数
    
    d - double值
    
    结果
    
    论证的无偏见指数
    
    从以下版本开始：
    
    1.6
  - nextAfter
```
public static double nextAfter(double start,                               double direction)
```
    返回第二个参数方向上第一个参数旁边的浮点数。如果两个参数比较相等，则返回第二个参数。
    特别案例：
    
    如果任一参数是NaN，则返回NaN。
    
    如果两个参数都是带符号的零，则返回direction不变（如果参数比较相等，则返回第二个参数的要求暗示）。
    
    如果start是± Double.MIN_VALUE且direction具有使得结果应具有较小幅度的值，则返回与start具有相同符号的零。
    
    如果start是无限且direction具有使得结果应具有较小幅度的值，则返回start ，其具有与start相同的符号。
    
    如果start等于± Double.MAX_VALUE且direction具有使得结果应具有更大幅度的值，则返回与start具有相同符号的无穷大。
    参数
    
    start - 启动浮点值
    
    direction - 表示应返回 start的邻居或 start哪一个的值
    
    结果
    
    与 start相邻的浮点数方向为 direction 。
    
    从以下版本开始：
    
    1.6
  - nextAfter
```
public static float nextAfter(float start,                              double direction)
```
    返回第二个参数方向上第一个参数旁边的浮点数。如果两个参数比较为相等，则返回与第二个参数等效的值。
    特别案例：
    
    如果任一参数是NaN，则返回NaN。
    
    如果两个参数都是带符号的零，则返回等效于direction的值。
    
    如果start是± Float.MIN_VALUE且direction具有使得结果应具有较小幅度的值，则返回与start具有相同符号的零。
    
    如果start是无限且direction具有使得结果应具有较小幅度的值，则返回start ，其具有与start相同的符号。
    
    如果start等于± Float.MAX_VALUE且direction具有使得结果应具有更大幅度的值，则返回具有与start相同的符号的无穷大。
    参数
    
    start - 启动浮点值
    
    direction - 表示应返回 start的邻居或 start哪一个的值
    
    结果
    
    与 start相邻的浮点数方向为 direction 。
    
    从以下版本开始：
    
    1.6
  - nextUp
```
public static double nextUp(double d)
```
    返回正无穷大方向上与d相邻的浮点值。此方法在语义上等效于nextAfter(d, Double.POSITIVE_INFINITY) ; 但是， nextUp实现可能比其等效的nextAfter调用运行得更快。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为正无穷大，则结果为正无穷大。
    
    如果参数为零，则结果为Double.MIN_VALUE
    参数
    
    d - 开始浮点值
    
    结果
    
    相邻的浮点值更接近正无穷大。
    
    从以下版本开始：
    
    1.6
  - nextUp
```
public static float nextUp(float f)
```
    返回正无穷大方向上与f相邻的浮点值。此方法在语义上等效于nextAfter(f, Float.POSITIVE_INFINITY) ; 但是， nextUp实现可能比其等效的nextAfter调用运行得更快。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为正无穷大，则结果为正无穷大。
    
    如果参数为零，则结果为Float.MIN_VALUE
    参数
    
    f - 启动浮点值
    
    结果
    
    相邻的浮点值更接近正无穷大。
    
    从以下版本开始：
    
    1.6
  - nextDown
```
public static double nextDown(double d)
```
    返回负无穷大方向上与d相邻的浮点值。此方法在语义上等效于nextAfter(d, Double.NEGATIVE_INFINITY) ; 但是， nextDown实现可能比其等效的nextAfter调用运行得更快。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为负无穷大，则结果为负无穷大。
    
    如果参数为零，则结果为-Double.MIN_VALUE
    参数
    
    d - 启动浮点值
    
    结果
    
    相邻的浮点值更接近负无穷大。
    
    从以下版本开始：
    
    1.8
  - nextDown
```
public static float nextDown(float f)
```
    返回负无穷大方向上与f相邻的浮点值。此方法在语义上等效于nextAfter(f, Float.NEGATIVE_INFINITY) ; 但是， nextDown实现可能比其等效的nextAfter调用运行得更快。
    特别案例：
    
    如果参数是NaN，则结果为NaN。
    
    如果参数为负无穷大，则结果为负无穷大。
    
    如果参数为零，则结果为-Float.MIN_VALUE
    参数
    
    f - 启动浮点值
    
    结果
    
    相邻的浮点值更接近负无穷大。
    
    从以下版本开始：
    
    1.8
  - scalb
```
public static double scalb(double d,                           int scaleFactor)
```
    返回d ×2 ^scaleFactor舍入，就像通过单个正确舍入的浮点乘以双^scaleFactor值集的成员一样。有关浮点值集的讨论，请参阅Java语言规范。如果结果的指数在Double.MIN_EXPONENT和Double.MAX_EXPONENT之间，则会准确计算答案。如果结果的指数大于Double.MAX_EXPONENT ，则返回无穷大。请注意，如果结果是低于正常的，则可能会丢失精度; 也就是说，当scalb(x, n)是低于正常时， scalb(scalb(x, n), -n)可能不等于x 。当结果为非NaN时，结果与d具有相同的符号。
    特别案例：
    
    如果第一个参数是NaN，则返回NaN。
    
    如果第一个参数是无穷大，则返回相同符号的无穷大。
    
    如果第一个参数为零，则返回相同符号的零。
    参数
    
    d - 要以2的幂进行缩放的数字。
    
    scaleFactor - 2的幂用于比例 d
    
    结果
    
    d 2 ^scaleFactor
    
    从以下版本开始：
    
    1.6
  - scalb
```
public static float scalb(float f,                          int scaleFactor)
```
    返回f ×2 ^scaleFactor舍入，就好像由单个正确舍入的浮点乘以浮点值集的成员一样。有关浮点值集的讨论，请参阅Java语言规范。如果结果的指数介于Float.MIN_EXPONENT和Float.MAX_EXPONENT之间，则会准确计算答案。如果结果的指数大于Float.MAX_EXPONENT ，则返回无穷大。请注意，如果结果是低于正常的，则可能会丢失精度; 也就是说，当scalb(x, n)是低于正常时， scalb(scalb(x, n), -n)可能不等于x 。当结果为非NaN时，结果与f具有相同的符号。
    特别案例：
    
    如果第一个参数是NaN，则返回NaN。
    
    如果第一个参数是无穷大，则返回相同符号的无穷大。
    
    如果第一个参数为零，则返回相同符号的零。
    参数
    
    f - 以2的幂为单位缩放的数字。
    
    scaleFactor - 功率2用于缩放 f
    
    结果
    
    f 2 ^scaleFactor
    
    从以下版本开始：
    
    1.6

Class Math

字段汇总

方法摘要

声明方法的类 java.lang.Object

字段详细信息

E

PI

方法详细信息

sin

cos

tan

asin

acos

atan

toRadians

toDegrees

exp

log

log10

sqrt

cbrt

IEEEremainder

ceil

floor

rint

atan2

pow

round

round

random

addExact

addExact

subtractExact

subtractExact

multiplyExact

multiplyExact

multiplyExact

incrementExact

incrementExact

decrementExact

decrementExact

negateExact

negateExact

toIntExact

multiplyFull

multiplyHigh

floorDiv

floorDiv

floorDiv

floorMod

floorMod

floorMod

abs

abs

abs

abs

max

max

max

max

min

min

min

min

fma

fma

ulp

ulp

signum

signum

sinh

cosh

tanh

hypot

expm1

log1p

copySign

copySign

getExponent

getExponent