Module java.base

Package java.lang

Class Math

java.lang.Object

java.lang.Math

       public final class Math extends Object
      

类Math包含执行基本数值操作的方法，例如基本指数、对数、平方根和三角函数。

与类StrictMath的一些数值方法不同，类Math的等效函数的所有实现未定义为返回完全相同的比特结果。这种放宽允许更好性能的实现，其中不需要严格的可重现性。

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

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

平台使用带符号的二进制补码整数算术与int和long原始类型。开发人员应选择原始类型，以确保算术运算始终产生正确的结果，这在某些情况下意味着操作不会溢出计算的值范围。最佳实践是选择原始类型和算法以避免溢出。在大小为int或long且需要检测溢出错误的情况下，方法名称以Exact结尾的方法在结果溢出时抛出ArithmeticException。

IEEE 754推荐操作

2019年修订的IEEE 754浮点标准包括推荐操作的部分以及这些操作的语义，如果它们包含在编程环境中。此类中包含的推荐操作包括sin、cos、tan、asin、acos、atan、exp、expm1、log、log10、log1p、sinh、cosh、tanh、hypot和pow。（sqrt操作是IEEE 754标准的一个必需部分，来自标准的另一部分。）推荐操作的特殊情况行为通常遵循IEEE 754标准的指导。但是，pow方法为一些参数定义了不同的行为，如其规范中所述。IEEE 754标准将其操作定义为正确舍入，这是比大多数方法要求的质量实现条件更严格的条件，这些方法也包含在此类中。

自：

1.0

参见：

• IEEE浮点算术标准

Field Summary

Fields

Modifier and Type	Field	Description
static final double	E	距离自然对数的底e最接近的double值。
static final double	PI	距离圆周与直径之比的圆周率π最接近的double值。
static final double	TAU	距离圆周与半径之比的圆周率τ最接近的double值。

Method Summary

Modifier and Type	Method	Description
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 int	absExact(int a)	如果可以精确表示为int值，则返回int值的数学绝对值，如果结果溢出正int范围，则抛出ArithmeticException。
static long	absExact(long a)	如果可以精确表示为long值，则返回long值的数学绝对值，如果结果溢出正long范围，则抛出ArithmeticException。
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)	返回从直角坐标（x，y）到极坐标（r，theta）的角度theta。
static double	cbrt(double a)	返回double值的立方根。
static double	ceil(double a)	返回大于或等于参数且等于数学整数的最小（最接近负无穷大）double值。
static int	ceilDiv(int x, int y)	返回大于或等于代数商的最小（最接近负无穷大）int值。
static long	ceilDiv(long x, int y)	返回大于或等于代数商的最小（最接近负无穷大）long值。
static long	ceilDiv(long x, long y)	返回大于或等于代数商的最小（最接近负无穷大）long值。
static int	ceilDivExact(int x, int y)	返回大于或等于代数商的最小（最接近负无穷大）int值。
static long	ceilDivExact(long x, long y)	返回大于或等于代数商的最小（最接近负无穷大）long值。
static int	ceilMod(int x, int y)	返回int参数的天花板模数。
static int	ceilMod(long x, int y)	返回long和int参数的天花板模数。
static long	ceilMod(long x, long y)	返回long参数的天花板模数。
static double	clamp(double value, double min, double max)	将值夹紧以适应最小值和最大值之间。
static float	clamp(float value, float min, float max)	将值夹紧以适应最小值和最大值之间。
static int	clamp(long value, int min, int max)	将值夹紧以适应最小值和最大值之间。
static long	clamp(long value, long min, long max)	将值夹紧以适应最小值和最大值之间。
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)	返回参数减一的值，如果结果溢出int，则抛出异常。
static long	decrementExact(long a)	返回参数减一的值，如果结果溢出long，则抛出异常。
static int	divideExact(int x, int y)	返回参数的商，如果结果溢出int，则抛出异常。
static long	divideExact(long x, long y)	返回参数的商，如果结果溢出long，则抛出异常。
static double	exp(double a)	返回e的double值的幂。
static double	expm1(double x)	返回ex -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	floorDivExact(int x, int y)	返回小于或等于代数商的最大（最接近正无穷大）int值。
static long	floorDivExact(long x, long y)	返回小于或等于代数商的最大（最接近正无穷大）long值。
static int	floorMod(int x, int y)	返回int参数的地板模数。
static int	floorMod(long x, int y)	返回long和int参数的地板模数。
static long	floorMod(long x, long y)	返回long参数的地板模数。
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(x2 +y2)，避免中间溢出或下溢。
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)	返回参数与1的和的自然对数。
static double	max(double a, double b)	返回两个double值中较大的一个。
static float	max(float a, float b)	返回两个float值中较大的一个。
static int	max(int a, int b)	返回两个int值中较大的一个。
static long	max(long a, long b)	返回两个long值中较大的一个。
static double	min(double a, double b)	返回两个double值中较小的一个。
static float	min(float a, float b)	返回两个float值中较小的一个。
static int	min(int a, int b)	返回两个int值中较小的一个。
static long	min(long a, long b)	返回两个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)	返回两个64位因子的128位乘积的最高64位作为long。
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值，等于数学整数。
static long	round(double a)	返回与参数最接近的long值，四舍五入到正无穷。
static int	round(float a)	返回与参数最接近的int值，四舍五入到正无穷。
static double	scalb(double d, int scaleFactor)	返回d × 2scaleFactor，如同通过单个正确舍入的浮点乘法执行般舍入。
static float	scalb(float f, int scaleFactor)	返回f × 2scaleFactor，如同通过单个正确舍入的浮点乘法执行般舍入。
static double	signum(double d)	返回参数的符号函数；如果参数为零，则为零，如果参数大于零，则为1.0，如果参数小于零，则为-1.0。
static float	signum(float f)	返回参数的符号函数；如果参数为零，则为零，如果参数大于零，则为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的大小。
static long	unsignedMultiplyHigh(long x, long y)	返回两个无符号64位因子的无符号128位乘积的最高64位作为long。

Methods declared in class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

E

             public static final double E
            

比任何其他值更接近e，自然对数的底。

参见：

• 常量字段值

PI

             public static final double PI
            

比任何其他值更接近pi（π），圆周率与直径的比值。

参见：

• 常量字段值

TAU

             public static final double TAU
            

比任何其他值更接近tau（τ），圆周率与半径的比值。

API注释：

pi的值是tau的一半；换句话说，tau是pi的两倍。

自：

19

参见：

• 常量字段值

Method Details

sin

             public static double sin(double a)
            

返回角度的三角正弦。特殊情况：

• 如果参数为NaN或无穷大，则结果为NaN。
• 如果参数为零，则结果为与参数相同符号的零。

计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。

参数：

a - 以弧度表示的角度。

返回：

参数的正弦值。

cos

             public static double cos(double a)
            

返回角度的三角余弦。特殊情况：

• 如果参数为NaN或无穷大，则结果为NaN。
• 如果参数为零，则结果为1.0。

计算结果必须在精确结果的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.0，结果为正零。

计算结果必须在精确结果的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)
            

返回自然对数的底 e 的 double 值的幂。特殊情况：

• 如果参数是 NaN，则结果是 NaN。
• 如果参数是正无穷大，则结果是正无穷大。
• 如果参数是负无穷大，则结果是正零。
• 如果参数是零，则结果是 1.0。

计算结果必须在精确结果的 1 ulp 范围内。结果必须是半单调的。

参数:

a - 要对 e 进行幂运算的指数

返回:

值 e^a，其中 e 是自然对数的底。

log

             public static double log(double a)
            

返回一个 double 值的自然对数（以 e 为底）。特殊情况：

• 如果参数是 NaN 或小于零，则结果是 NaN。
• 如果参数是正无穷大，则结果是正无穷大。
• 如果参数是正零或负零，则结果是负无穷大。
• 如果参数是 1.0，则结果是正零。

计算结果必须在精确结果的 1 ulp 范围内。结果必须是半单调的。

参数:

a - 一个值

返回:

值 ln a，即 a 的自然对数。

log10

             public static double log10(double a)
            

返回一个 double 值的以 10 为底的对数。特殊情况：

• 如果参数是 NaN 或小于零，则结果是 NaN。
• 如果参数是正无穷大，则结果是正无穷大。
• 如果参数是正零或负零，则结果是负无穷大。
• 如果参数等于 10ⁿ，其中 n 是整数，则结果是 n。特别地，如果参数是 1.0（10⁰），则结果是正零。

计算结果必须在精确结果的 1 ulp 范围内。结果必须是半单调的。

参数:

a - 一个值

返回:

a 的以 10 为底的对数。

自版本:

1.5

sqrt

             public static double sqrt(double a)
            

返回一个 double 值的正确舍入的正平方根。特殊情况：

• 如果参数是 NaN 或小于零，则结果是 NaN。
• 如果参数是正无穷大，则结果是正无穷大。
• 如果参数是正零或负零，则结果与参数相同。

否则，结果是最接近参数值的真实数学平方根的 double 值。

API 注释:

此方法对应于 IEEE 754 中定义的 squareRoot 操作。

参数:

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 × 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) 的值。

API 注释:

此方法对应于 IEEE 754 中定义的 roundToIntegralTowardPositive 操作。

参数:

a - 一个值。

返回:

大于或等于参数且等于数学整数的最小（最接近负无穷大）浮点值。

floor

             public static double floor(double a)
            

返回小于或等于参数且等于数学整数的最大（最接近正无穷大）double 值。特殊情况：

• 如果参数值已经等于数学整数，则结果与参数相同。
• 如果参数是 NaN 或无穷大或正零或负零，则结果与参数相同。

API 注释:

此方法对应于 IEEE 754 中定义的 roundToIntegralTowardNegative 操作。

参数:

a - 一个值。

返回:

小于或等于参数且等于数学整数的最大（最接近正无穷大）浮点值。

rint

             public static double rint(double a)
            

返回与参数最接近且等于数学整数的double 值。如果两个数学整数值等距离，则结果是偶数值。特殊情况：

• 如果参数值已经等于数学整数，则结果与参数相同。
• 如果参数是 NaN 或无穷大或正零或负零，则结果与参数相同。

API 注释:

此方法对应于 IEEE 754 中定义的 roundToIntegralTiesToEven 操作。

参数:

a - 一个 double 值。

返回:

最接近参数且等于数学整数的浮点值。

atan2

             public static double atan2(double y, double x)
            

返回从直角坐标（x，y）转换为极坐标（r，theta）的角度 theta。此方法通过计算 y/x 的反正切来计算相位 theta，范围为 -pi 到 pi。特殊情况：

• 如果任一参数是 NaN，则结果是 NaN。
• 如果第一个参数是正零且第二个参数是正数，或第一个参数是正且有限且第二个参数是正无穷大，则结果是正零。
• 如果第一个参数是负零且第二个参数是正数，或第一个参数是负且有限且第二个参数是正无穷大，则结果是负零。
• 如果第一个参数是正零且第二个参数是负数，或第一个参数是正且有限且第二个参数是负无穷大，则结果是最接近 pi 的 double 值。
• 如果第一个参数是负零且第二个参数是负数，或第一个参数是负且有限且第二个参数是负无穷大，则结果是最接近 -pi 的 double 值。
• 如果第一个参数是正且第二个参数是正零或负零，或第一个参数是正无穷大且第二个参数是有限数，则结果是最接近 pi/2 的 double 值。
• 如果第一个参数是负且第二个参数是正零或负零，或第一个参数是负无穷大且第二个参数是有限数，则结果是最接近 -pi/2 的 double 值。
• 如果两个参数都是正无穷大，则结果是最接近 pi/4 的 double 值。
• 如果第一个参数是正无穷大且第二个参数是负无穷大，则结果是最接近 3*pi/4 的 double 值。
• 如果第一个参数是负无穷大且第二个参数是正无穷大，则结果是最接近 -pi/4 的 double 值。
• 如果两个参数都是负无穷大，则结果是最接近 -3*pi/4 的 double 值。

计算结果必须在精确结果的 2 ulps 范围内。结果必须是半单调的。

API注释:

对于带有正号和有限非零x的y，atan2的精确数学值等于：

• 如果x > 0，则为atan(abs(y/x))
• 如果x < 0，则为π - atan(abs(y/x))

参数:

y - 纵坐标

x - 横坐标

返回:

笛卡尔坐标中对应于点（x，y）的极坐标点（r，theta）中的theta分量。

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范围内。结果必须是半单调的。

API注释:

该方法的特殊情况定义与IEEE 754推荐的 pow操作的特殊情况定义不同，对于±1.0的无限幂，此方法将这些情况视为不定，并指定返回NaN。IEEE 754规范将无限幂视为一个大整数（大幅度的浮点数是数值整数，具体来说是偶数整数），因此规定返回1.0。

参数:

a - 底数。

b - 指数。

返回:

值ab。

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注释:

由于小于1.0的最大double值是Math.nextDown(1.0)，在闭区间[x1,x2]中定义值x，其中x1<=x2，可以通过以下语句定义

 double f = Math.random()/Math.nextDown(1.0);
 double x = x1*(1.0 - f) + x2*f;
 

返回:

大于或等于0.0且小于1.0的伪随机double值。

参见:

• 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 - 如果结果溢出long

自:

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 - 如果结果溢出long

自:

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 - 如果结果溢出long

自版本:

9

multiplyExact

             public static long multiplyExact(long x, long y)
            

返回参数的乘积，如果结果溢出long则抛出异常。

参数:

x - 第一个值

y - 第二个值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出long

自版本:

1.8

divideExact

             public static int divideExact(int x, int y)
            

返回参数的商，如果结果溢出int则抛出异常。如果在此方法中发生溢出，即x为Integer.MIN_VALUE且y为-1。相反，如果直接计算Integer.MIN_VALUE / -1，结果将是Integer.MIN_VALUE，不会抛出异常。

如果y为零，则抛出ArithmeticException（JLS 15.17.2）。

内置的求余运算符"%"既适用于此方法，也适用于内置的除法运算符"/"。

参数:

x - 被除数

y - 除数

返回:

商 x / y

抛出:

ArithmeticException - 如果y为零或商溢出int

参见 Java语言规范:

15.17.2 除法运算符 /

自版本:

18

divideExact

             public static long divideExact(long x, long y)
            

返回参数的商，如果结果溢出long则抛出异常。如果在此方法中发生溢出，即x为Long.MIN_VALUE且y为-1。相反，如果直接计算Long.MIN_VALUE / -1，结果将是Long.MIN_VALUE，不会抛出异常。

如果y为零，则抛出ArithmeticException（JLS 15.17.2）。

内置的求余运算符"%"既适用于此方法，也适用于内置的除法运算符"/"。

参数:

x - 被除数

y - 除数

返回:

商 x / y

抛出:

ArithmeticException - 如果y为零或商溢出long

参见 Java语言规范:

15.17.2 除法运算符 /

自版本:

18

floorDivExact

             public static int floorDivExact(int x, int y)
            

返回最接近正无穷大的int值，该值小于或等于代数商。此方法与floorDiv(int,int)相同，只是当被除数为Integer.MIN_VALUE且除数为-1时，会抛出ArithmeticException，而不是忽略整数溢出并返回Integer.MIN_VALUE。

地板取模方法floorMod(int,int)既适用于此方法，也适用于floorDiv(int,int)方法。

有关示例，请参见floorDiv(int, int)。

参数:

x - 被除数

y - 除数

返回:

最接近正无穷大的int值，该值小于或等于代数商。

抛出:

ArithmeticException - 如果除数y为零，或被除数x为Integer.MIN_VALUE且除数y为-1。

自版本:

18

参见:

• floorDiv(int, int)

floorDivExact

             public static long floorDivExact(long x, long y)
            

返回最接近正无穷大的long值，该值小于或等于代数商。此方法与floorDiv(long,long)相同，只是当被除数为Long.MIN_VALUE且除数为-1时，会抛出ArithmeticException，而不是忽略整数溢出并返回Long.MIN_VALUE。

地板取模方法floorMod(long,long)既适用于此方法，也适用于floorDiv(long,long)方法。

有关示例，请参见floorDiv(int, int)。

参数:

x - 被除数

y - 除数

返回:

最接近正无穷大的long值，该值小于或等于代数商。

抛出:

ArithmeticException - 如果除数y为零，或被除数x为Long.MIN_VALUE且除数y为-1。

自版本:

18

参见:

• floorDiv(long,long)

ceilDivExact

             public static int ceilDivExact(int x, int y)
            

返回最接近负无穷大的int值，该值大于或等于代数商。此方法与ceilDiv(int,int)相同，只是当被除数为Integer.MIN_VALUE且除数为-1时，会抛出ArithmeticException，而不是忽略整数溢出并返回Integer.MIN_VALUE。

天花板取模方法ceilMod(int,int)既适用于此方法，也适用于ceilDiv(int,int)方法。

有关示例，请参见ceilDiv(int, int)。

参数:

x - 被除数

y - 除数

返回:

最接近负无穷大的int值，该值大于或等于代数商。

抛出:

ArithmeticException - 如果除数y为零，或被除数x为Integer.MIN_VALUE且除数y为-1。

自版本:

18

参见:

• ceilDiv(int, int)

ceilDivExact

             public static long ceilDivExact(long x, long y)
            

返回最接近负无穷大的long值，该值大于或等于代数商。此方法与ceilDiv(long,long)相同，只是当被除数为Long.MIN_VALUE且除数为-1时，会抛出ArithmeticException，而不是忽略整数溢出并返回Long.MIN_VALUE。

天花板取模方法ceilMod(long,long)既适用于此方法，也适用于ceilDiv(long,long)方法。

有关示例，请参见ceilDiv(int, int)。

参数:

x - 被除数

y - 除数

返回:

最接近负无穷大的long值，该值大于或等于代数商。

抛出:

ArithmeticException - 如果除数y为零，或被除数x为Long.MIN_VALUE且除数y为-1。

自版本:

18

参见:

• ceilDiv(long,long)

incrementExact

             public static int incrementExact(int a)
            

返回增加一的参数，如果结果溢出int则抛出异常。溢出仅发生在最大值。

参数:

a - 要增加的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出int

自版本:

1.8

incrementExact

             public static long incrementExact(long a)
            

返回增加一的参数，如果结果溢出long则抛出异常。溢出仅发生在最大值。

参数:

a - 要递增的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出 long 类型

自版本:

1.8

decrementExact

             public static int decrementExact(int a)
            

返回递减一个参数，如果结果溢出 int 类型则抛出异常。溢出仅发生在 最小值 处。

参数:

a - 要递减的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出 int 类型

自版本:

1.8

decrementExact

             public static long decrementExact(long a)
            

返回递减一个参数，如果结果溢出 long 类型则抛出异常。溢出仅发生在 最小值 处。

参数:

a - 要递减的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出 long 类型

自版本:

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 - 如果结果溢出 long 类型

自版本:

1.8

toIntExact

             public static int toIntExact(long value)
            

返回 long 类型参数的值，如果值溢出 int 类型则抛出异常。

参数:

value - long 值

返回:

参数作为 int 类型返回

抛出:

ArithmeticException - 如果参数溢出 int 类型

自版本:

1.8

multiplyFull

             public static long multiplyFull(int x, int y)
            

返回参数的精确数学乘积。

参数:

x - 第一个值

y - 第二个值

返回:

结果

自版本:

9

multiplyHigh

             public static long multiplyHigh(long x, long y)
            

返回两个 64 位因子的 128 位乘积的最高有效 64 位作为 long 类型。

参数:

x - 第一个值

y - 第二个值

返回:

结果

自版本:

9

参见:

• unsignedMultiplyHigh(long, long)

unsignedMultiplyHigh

             public static long unsignedMultiplyHigh(long x, long y)
            

返回两个无符号 64 位因子的无符号 128 位乘积的最高有效 64 位作为 long 类型。

参数:

x - 第一个值

y - 第二个值

返回:

结果

自版本:

18

参见:

• multiplyHigh(long, long)

floorDiv

             public static int floorDiv(int x, int y)
            

返回最接近正无穷大的最大（小于或等于）int 值，该值小于或等于代数商。有一个特殊情况：如果被除数是 Integer.MIN_VALUE，且除数是 -1，则会发生整数溢出，结果等于 Integer.MIN_VALUE。

普通整数除法采用向零舍入模式（截断）。此操作相反采用向负无穷大（floor）舍入模式。floor 舍入模式在确切商不是整数且为负数时与截断产生不同的结果。

• 如果参数的符号相同，则 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。

普通整数除法采用向零舍入模式（截断）。此操作相反采用向负无穷大（floor）舍入模式。floor 舍入模式在确切结果不是整数且为负数时与截断产生不同的结果。

有关示例，请参见 floorDiv(int, int)。

参数:

x - 被除数

y - 除数

返回:

最大（小于或等于）long 值，该值小于或等于代数商。

抛出:

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。

普通整数除法采用向零舍入模式（截断）。此操作相反采用向负无穷大（floor）舍入模式。floor 舍入模式在确切结果不是整数且为负数时与截断产生不同的结果。

有关示例，请参见 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 模数。

floor 模数为 r = x - (floorDiv(x, y) * y)，与除数 y 的符号相同或为零，并且在 -abs(y) < r < +abs(y) 范围内。

floorDiv 和 floorMod 之间的关系是：

• floorDiv(x, y) * y + floorMod(x, y) == x

floorMod 和 % 运算符之间的值差异是由于 floorDiv 和 / 运算符之间的差异导致的，详见 floorDiv(int, int)。

示例：

• 无论参数的符号如何，floorMod(x, y) 仅在 x % y 为零时也为零。
• 如果 floorMod(x, y) 和 x % y 都不为零，则它们仅在参数的符号不同时不同。
  
  • floorMod(+4, +3) == +1; 且 (+4 % +3) == +1
  • floorMod(-4, -3) == -1; 且 (-4 % -3) == -1
  • floorMod(+4, -3) == -2; 且 (+4 % -3) == +1
  • floorMod(-4, +3) == +2; 且 (-4 % +3) == -1

参数:

x - 被除数

y - 除数

返回:

floor 模数 x - (floorDiv(x, y) * y)

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

1.8

参见:

• floorDiv(int, int)

floorMod

             public static int floorMod(long x, int y)
            

返回long和int参数的地板取模。

地板取模是r = x - (floorDiv(x, y) * y)，与除数y具有相同的符号或为零，并且在-abs(y) < r < +abs(y)范围内。

floorDiv和floorMod之间的关系如下：

• 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参数的地板取模。

地板取模是r = x - (floorDiv(x, y) * y)，与除数y具有相同的符号或为零，并且在-abs(y) < r < +abs(y)范围内。

floorDiv和floorMod之间的关系如下：

• 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)

ceilDiv

             public static int ceilDiv(int x, int y)
            

返回大于或等于代数商的最小（最接近负无穷大）int值。有一个特殊情况：如果被除数是Integer.MIN_VALUE且除数是-1，则会发生整数溢出，结果等于Integer.MIN_VALUE。

正常的整数除法采用向零舍入模式（截断）。此操作相反采用向正无穷大舍入模式（上取整）。上取整舍入模式在确切商不是整数且为正数时与截断产生不同的结果。

• 如果参数的符号不同，则ceilDiv和/运算符的结果相同。
  例如，ceilDiv(-4, 3) == -1且(-4 / 3) == -1。
• 如果参数的符号相同，ceilDiv返回大于或等于商的最小整数，而/运算符返回小于或等于商的最大整数。它们仅在商不是整数时有所不同。
  例如，ceilDiv(4, 3) == 2，而(4 / 3) == 1。

参数：

x - 被除数

y - 除数

返回：

大于或等于代数商的最小（最接近负无穷大）int值。

抛出：

ArithmeticException - 如果除数y为零

自版本：

18

另请参见：

• ceilMod(int, int)
• ceil(double)

ceilDiv

             public static long ceilDiv(long x, int y)
            

返回大于或等于代数商的最小（最接近负无穷大）long值。有一个特殊情况：如果被除数是Long.MIN_VALUE且除数是-1，则会发生整数溢出，结果等于Long.MIN_VALUE。

正常的整数除法采用向零舍入模式（截断）。此操作相反采用向正无穷大舍入模式（上取整）。上取整舍入模式在确切结果不是整数且为正数时与截断产生不同的结果。

示例，请参见ceilDiv(int, int)。

参数：

x - 被除数

y - 除数

返回：

大于或等于代数商的最小（最接近负无穷大）long值。

抛出：

ArithmeticException - 如果除数y为零

自版本：

18

另请参见：

• ceilMod(int, int)
• ceil(double)

ceilDiv

             public static long ceilDiv(long x, long y)
            

返回大于或等于代数商的最小（最接近负无穷大）long值。有一个特殊情况：如果被除数是Long.MIN_VALUE且除数是-1，则会发生整数溢出，结果等于Long.MIN_VALUE。

正常的整数除法采用向零舍入模式（截断）。此操作相反采用向正无穷大舍入模式（上取整）。上取整舍入模式在确切结果不是整数且为正数时与截断产生不同的结果。

示例，请参见ceilDiv(int, int)。

参数：

x - 被除数

y - 除数

返回：

大于或等于代数商的最小（最接近负无穷大）long值。

抛出：

ArithmeticException - 如果除数y为零

自版本：

18

另请参见：

• ceilMod(int, int)
• ceil(double)

ceilMod

             public static int ceilMod(int x, int y)
            

返回int参数的上取整取模。

上取整取模是r = x - (ceilDiv(x, y) * y)，与除数y具有相反的符号或为零，并且在-abs(y) < r < +abs(y)范围内。

ceilDiv和ceilMod之间的关系如下：

• ceilDiv(x, y) * y + ceilMod(x, y) == x

ceilMod和%运算符之间的值差异是由于ceilDiv和/运算符之间的差异，详见ceilDiv(int, int)。

示例：

• 无论参数的符号如何，当且仅当x % y也为零时，ceilMod(x, y)为零。
• 如果ceilMod(x, y)和x % y都不为零，则它们仅在参数的符号相同时有所不同。
  
  • ceilMod(+4, +3) == -2； 和 (+4 % +3) == +1
  • ceilMod(-4, -3) == +2； 和 (-4 % -3) == -1
  • ceilMod(+4, -3) == +1； 和 (+4 % -3) == +1
  • ceilMod(-4, +3) == -1； 和 (-4 % +3) == -1

参数：

x - 被除数

y - 除数

返回：

上取整取模x - (ceilDiv(x, y) * y)

抛出：

ArithmeticException - 如果除数y为零

自版本：

18

另请参见：

• ceilDiv(int, int)

ceilMod

             public static int ceilMod(long x, int y)
            

返回long和int参数的上取整取模。

上取整取模是r = x - (ceilDiv(x, y) * y)，与除数y具有相反的符号或为零，并且在-abs(y) < r < +abs(y)范围内。

ceilDiv和ceilMod之间的关系如下：

• ceilDiv(x, y) * y + ceilMod(x, y) == x

示例，请参见ceilMod(int, int)。

参数：

x - 被除数

y - 除数

返回：

上取整取模x - (ceilDiv(x, y) * y)

抛出：

ArithmeticException - 如果除数y为零

自版本：

18

另请参见：

• ceilDiv(long, int)

ceilMod

             public static long ceilMod(long x, long y)
            

返回long参数的上取整取模。

上取整取模是r = x - (ceilDiv(x, y) * y)，与除数y具有相反的符号或为零，并且在-abs(y) < r < +abs(y)范围内。

ceilDiv和ceilMod之间的关系如下：

• ceilDiv(x, y) * y + ceilMod(x, y) == x

示例，请参见ceilMod(int, int)。

参数：

x - 被除数

y - 除数

返回：

上取整取模x - (ceilDiv(x, y) * y)

抛出：

ArithmeticException - 如果除数y为零

自版本：

18

另请参见：

abs

             public static int abs(int a)
            

返回一个int值的绝对值。如果参数不是负数，则返回参数。如果参数是负数，则返回参数的负值。

请注意，如果参数等于Integer.MIN_VALUE的值，即可表示的最负值的int值，则结果是相同的负值。相比之下，absExact(int)方法对于这个值会抛出ArithmeticException异常。

参数:

a - 要确定绝对值的参数

返回:

参数的绝对值。

另请参见:

• absExact(int)

absExact

             public static int absExact(int a)
            

返回一个int值的数学绝对值，如果它可以精确表示为一个int，则在结果溢出正int范围时抛出ArithmeticException异常。

由于二进制补码整数的范围是不对称的，有一个额外的负值（JLS 4.2.1），Integer.MIN_VALUE的数学绝对值会溢出正int范围，因此对于该参数会抛出异常。

参数:

a - 要确定绝对值的参数

返回:

参数的绝对值，除非发生溢出

抛出:

ArithmeticException - 如果参数是Integer.MIN_VALUE

自:

15

另请参见:

• abs(int)

abs

             public static long abs(long a)
            

返回一个long值的绝对值。如果参数不是负数，则返回参数。如果参数是负数，则返回参数的负值。

请注意，如果参数等于Long.MIN_VALUE的值，即可表示的最负值的long值，则结果是相同的负值。相比之下，absExact(long)方法对于这个值会抛出ArithmeticException异常。

参数:

a - 要确定绝对值的参数

返回:

参数的绝对值。

另请参见:

• absExact(long)

absExact

             public static long absExact(long a)
            

返回一个long值的数学绝对值，如果它可以精确表示为一个long，则在结果溢出正long范围时抛出ArithmeticException异常。

由于二进制补码整数的范围是不对称的，有一个额外的负值（JLS 4.2.1），Long.MIN_VALUE的数学绝对值会溢出正long范围，因此对于该参数会抛出异常。

参数:

a - 要确定绝对值的参数

返回:

参数的绝对值，除非发生溢出

抛出:

ArithmeticException - 如果参数是Long.MIN_VALUE

自:

15

另请参见:

• abs(long)

abs

             public static float abs(float a)
            

返回一个float值的绝对值。如果参数不是负数，则返回参数。如果参数是负数，则返回参数的负值。特殊情况：

• 如果参数是正零或负零，则结果是正零。
• 如果参数是无穷大，则结果是正无穷大。
• 如果参数是NaN，则结果是NaN。

API注释:

如上所示，该方法的一个有效实现由下面的表达式给出，该表达式计算一个具有与参数相同指数和尾数的float，但保证零符号位指示为正值：
Float.intBitsToFloat(0x7fffffff & Float.floatToRawIntBits(a))

参数:

a - 要确定绝对值的参数

返回:

参数的绝对值。

abs

             public static double abs(double a)
            

返回一个double值的绝对值。如果参数不是负数，则返回参数。如果参数是负数，则返回参数的负值。特殊情况：

• 如果参数是正零或负零，则结果是正零。
• 如果参数是无穷大，则结果是正无穷大。
• 如果参数是NaN，则结果是NaN。

API注释:

如上所示，该方法的一个有效实现由下面的表达式给出，该表达式计算一个具有与参数相同指数和尾数的double，但保证零符号位指示为正值：
Double.longBitsToDouble((Double.doubleToRawLongBits(a)<<1)>>>1)

参数:

a - 要确定绝对值的参数

返回:

参数的绝对值。

max

             public static int max(int a, int b)
            

返回两个int值中较大的值。即，结果是更接近Integer.MAX_VALUE值的参数。如果参数具有相同的值，则结果是相同的值。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较大的值。

max

             public static long max(long a, long b)
            

返回两个long值中较大的值。即，结果是更接近Long.MAX_VALUE值的参数。如果参数具有相同的值，则结果是相同的值。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较大的值。

max

             public static float max(float a, float b)
            

返回两个float值中较大的值。即，结果是更接近正无穷大的参数。如果参数具有相同的值，则结果是相同的值。如果任一值为NaN，则结果为NaN。与数值比较运算符不同，此方法认为负零严格小于正零。如果一个参数是正零，另一个是负零，则结果是正零。

API注释:

该方法对应于IEEE 754中定义的最大操作。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较大的值。

max

             public static double max(double a, double b)
            

返回两个double值中较大的值。即，结果是更接近正无穷大的参数。如果参数具有相同的值，则结果是相同的值。如果任一值为NaN，则结果为NaN。与数值比较运算符不同，此方法认为负零严格小于正零。如果一个参数是正零，另一个是负零，则结果是正零。

API注释:

该方法对应于IEEE 754中定义的最大操作。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较大的值。

min

             public static int min(int a, int b)
            

返回两个int值中较小的值。即，结果是更接近Integer.MIN_VALUE值的参数。如果参数具有相同的值，则结果是相同的值。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较小的值。

min

             public static long min(long a, long b)
            

返回两个long值中较小的值。即，结果是更接近Long.MIN_VALUE值的参数。如果参数具有相同的值，则结果是相同的值。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较小的值。

min

             public static float min(float a, float b)
            

返回两个float值中较小的值。即，结果是更接近负无穷大的参数。如果参数具有相同的值，则结果是相同的值。如果任一值为NaN，则结果为NaN。与数值比较运算符不同，此方法认为负零严格小于正零。如果一个参数是正零，另一个是负零，则结果是负零。

API注释:

该方法对应于IEEE 754中定义的最小操作。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较小的值。

min

             public static double min(double a, double b)
            

返回两个double值中较小的值。即，结果是更接近负无穷大的参数。如果参数具有相同的值，则结果是相同的值。如果任一值为NaN，则结果为NaN。与数值比较运算符不同，此方法认为负零严格小于正零。如果一个参数是正零，另一个是负零，则结果是负零。

API注释:

该方法对应于IEEE 754中定义的最小操作。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较小的值。

clamp

             public static int clamp(long value, int min, int max)
            

将值夹紧以适应最小值和最大值。如果值小于min，则返回min。如果值大于max，则返回max。否则，返回原始值。

虽然 long 类型的原始值可能不适合 int 类型，但边界具有 int 类型，因此结果始终适合 int 类型。这允许使用该方法将 long 值安全地转换为带饱和度的 int。

参数:

value - 要夹紧的值

min - 允许的最小值

max - 允许的最大值

返回:

一个夹紧的值，适合于min..max区间

抛出:

IllegalArgumentException - 如果min > max

自 JDK 版本:

21

clamp

             public static long clamp(long value, long min, long max)
            

将值夹紧以适应最小值和最大值。如果值小于min，则返回min。如果值大于max，则返回max。否则，返回原始值。

参数:

value - 要夹紧的值

min - 允许的最小值

max - 允许的最大值

返回:

一个夹紧的值，适合于min..max区间

抛出:

IllegalArgumentException - 如果min > max

自 JDK 版本:

21

clamp

             public static double clamp(double value, double min, double max)
            

将值夹紧以适应最小值和最大值。如果值小于min，则返回min。如果值大于max，则返回max。否则，返回原始值。如果值为 NaN，则结果也为 NaN。

与数值比较运算符不同，此方法认为负零严格小于正零。例如，clamp(-0.0, 0.0, 1.0) 返回 0.0。

参数:

value - 要夹紧的值

min - 允许的最小值

max - 允许的最大值

返回:

一个夹紧的值，适合于min..max区间

抛出:

IllegalArgumentException - 如果min 和 max 参数中的任一值为 NaN，或者min > max，或者min 为 +0.0，且 max 为 -0.0。

自 JDK 版本:

21

clamp

             public static float clamp(float value, float min, float max)
            

将值夹紧以适应最小值和最大值。如果值小于min，则返回min。如果值大于max，则返回max。否则，返回原始值。如果值为 NaN，则结果也为 NaN。

与数值比较运算符不同，此方法认为负零严格小于正零。例如，clamp(-0.0f, 0.0f, 1.0f) 返回 0.0f。

参数:

value - 要夹紧的值

min - 允许的最小值

max - 允许的最大值

返回:

一个夹紧的值，适合于min..max区间

抛出:

IllegalArgumentException - 如果min 和 max 参数中的任一值为 NaN，或者min > max，或者min 为 +0.0f，且 max 为 -0.0f。

自 JDK 版本:

21

fma

             public static double fma(double a, double b, double c)
            

返回三个参数的融合乘加；即，返回前两个参数的精确乘积与第三个参数相加，然后将结果四舍五入一次到最接近的double。四舍五入使用最接近偶数舍入模式。相比之下，如果将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 注释:

此方法对应于 IEEE 754 中定义的融合乘加操作。

参数:

a - 一个值

b - 一个值

c - 一个值

返回:

(a × b + c) 计算结果，就像具有无限范围和精度一样，并四舍五入一次到最接近的double值

自 JDK 版本:

9

fma

             public static float fma(float a, float b, float c)
            

返回三个参数的融合乘加；即，返回前两个参数的精确乘积与第三个参数相加，然后将结果四舍五入一次到最接近的float。四舍五入使用最接近偶数舍入模式。相比之下，如果将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 注释:

此方法对应于 IEEE 754 中定义的融合乘加操作。

参数:

a - 一个值

b - 一个值

c - 一个值

返回:

(a × b + c) 计算结果，就像具有无限范围和精度一样，并四舍五入一次到最接近的float值

自 JDK 版本:

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 的大小

自 JDK 版本:

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 的大小

自 JDK 版本:

1.5

signum

             public static double signum(double d)
            

返回参数的符号函数；如果参数为零，则返回零，如果参数大于零，则返回 1.0，如果参数小于零，则返回 -1.0。

特殊情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数为正零或负零，则结果与参数相同。

参数:

d - 要返回其符号的浮点值

返回:

参数的符号函数

自 JDK 版本:

1.5

signum

             public static float signum(float f)
            

返回参数的符号函数；如果参数为零，则返回零，如果参数大于零，则返回 1.0f，如果参数小于零，则返回 -1.0f。

特殊情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数为正零或负零，则结果与参数相同。

参数:

f - 要返回其符号的浮点值

返回:

参数的符号函数

自 JDK 版本:

1.5

sinh

             public static double sinh(double x)
            

返回double值的双曲正弦值。双曲正弦值x被定义为(e^x - e^-x)/2，其中e是欧拉数。

特殊情况：

• 如果参数为 NaN，则结果为 NaN。

参数:

x - 要返回其双曲正弦值的数字。

返回:

x的双曲正弦值。

自版本:

1.5

cosh

             public static double cosh(double x)
            

返回一个double值的双曲余弦值。双曲余弦值x被定义为(e^x + e^-x)/2，其中e是欧拉数。

特殊情况:

• 如果参数是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的极限值的1/2 ulp范围内，应返回正确符号的±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的精确和要比exp(x)的浮点评估结果更接近e^x。

特殊情况:

• 如果参数是NaN，则结果为NaN。
• 如果参数是正无穷，则结果为正无穷。
• 如果参数是负无穷，则结果为-1.0。
• 如果参数是零，则结果是与参数相同符号的零。

计算结果必须在精确结果的1 ulp范围内。结果必须是半单调的。对于任何有限输入，expm1的结果必须大于或等于-1.0。请注意，一旦ex - 1的精确结果在-1的1/2 ulp极限值范围内，应返回-1.0。

参数:

x - 在计算ex -1时要提升的指数。

返回:

值ex - 1。

自版本:

1.5

log1p

             public static double log1p(double x)
            

返回参数和1的自然对数之和。请注意，对于小值x，log1p(x)的结果比ln(1 + 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(double,double)方法不同，此方法不要求将NaN sign参数视为正值；允许实现将某些NaN参数视为正值，将其他NaN参数视为负值，以提高性能。

API注释:

此方法对应于IEEE 754中定义的copySign操作。

参数:

magnitude - 提供结果的幅度的参数

sign - 提供结果的符号的参数

返回:

一个具有magnitude幅度和sign符号的值。

自版本:

1.6

copySign

             public static float copySign(float magnitude, float sign)
            

返回第一个浮点参数与第二个浮点参数的符号相同。请注意，与StrictMath.copySign(float,float)方法不同，此方法不要求将NaN sign参数视为正值；允许实现将某些NaN参数视为正值，将其他NaN参数视为负值，以提高性能。

API注释:

此方法对应于IEEE 754中定义的copySign操作。

参数:

magnitude - 提供结果的幅度的参数

sign - 提供结果的符号的参数

返回:

一个具有magnitude幅度和sign符号的值。

自版本:

1.6

getExponent

             public static int getExponent(float f)
            

返回用于表示float的无偏指数。特殊情况:

• 如果参数是NaN或无穷大，则结果为Float.MAX_EXPONENT + 1。
• 如果参数是零或次正规数，则结果为Float.MIN_EXPONENT - 1。

API注释:

此方法类似于IEEE 754中定义的logB操作，但对次正规参数返回不同的值。

参数:

f - 一个float值

返回:

参数的无偏指数

自版本:

1.6

getExponent

             public static int getExponent(double d)
            

返回用于表示double的无偏指数。特殊情况:

• 如果参数是NaN或无穷大，则结果为Double.MAX_EXPONENT + 1。
• 如果参数是零或次正规数，则结果为Double.MIN_EXPONENT - 1。

API注释:

此方法类似于IEEE 754中定义的logB操作，但对次正规参数返回不同的值。

参数:

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相同符号的Double.MAX_VALUE。
• 如果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具有相同符号的Float.MAX_VALUE。
• 如果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

API注释：

该方法对应于IEEE 754中定义的nextUp操作。

参数：

d - 起始浮点值

返回：

更接近正无穷大的相邻浮点值。

自：

1.6

nextUp

             public static float nextUp(float f)
            

返回与f在正无穷大方向上相邻的浮点值。该方法在语义上等同于nextAfter(f, Float.POSITIVE_INFINITY)；但是，nextUp的实现可能比其等效的nextAfter调用更快。

特殊情况：

• 如果参数为NaN，则结果为NaN。
• 如果参数为正无穷大，则结果为正无穷大。
• 如果参数为零，则结果为Float.MIN_VALUE

API注释：

该方法对应于IEEE 754中定义的nextUp操作。

参数：

f - 起始浮点值

返回：

更接近正无穷大的相邻浮点值。

自：

1.6

nextDown

             public static double nextDown(double d)
            

返回与d在负无穷大方向上相邻的浮点值。该方法在语义上等同于nextAfter(d, Double.NEGATIVE_INFINITY)；但是，nextDown的实现可能比其等效的nextAfter调用更快。

特殊情况：

• 如果参数为NaN，则结果为NaN。
• 如果参数为负无穷大，则结果为负无穷大。
• 如果参数为零，则结果为-Double.MIN_VALUE

API注释：

该方法对应于IEEE 754中定义的nextDown操作。

参数：

d - 起始浮点值

返回：

更接近负无穷大的相邻浮点值。

自：

1.8

nextDown

             public static float nextDown(float f)
            

返回与f在负无穷大方向上相邻的浮点值。该方法在语义上等同于nextAfter(f, Float.NEGATIVE_INFINITY)；但是，nextDown的实现可能比其等效的nextAfter调用更快。

特殊情况：

• 如果参数为NaN，则结果为NaN。
• 如果参数为负无穷大，则结果为负无穷大。
• 如果参数为零，则结果为-Float.MIN_VALUE

API注释：

该方法对应于IEEE 754中定义的nextDown操作。

参数：

f - 起始浮点值

返回：

更接近负无穷大的相邻浮点值。

自：

1.8

scalb

             public static double scalb(double d, int scaleFactor)
            

返回d × 2^scaleFactor，四舍五入，如同由单个正确舍入的浮点乘法执行。如果结果的指数在Double.MIN_EXPONENT和Double.MAX_EXPONENT之间，则答案将被精确计算。如果结果的指数大于 Double.MAX_EXPONENT，则返回无穷大。请注意，如果结果是次正规的，则可能会丢失精度；也就是说，当scalb(x, n)为次正规时，scalb(scalb(x, n), -n)可能不等于x。当结果为非NaN时，结果与d具有相同的符号。

特殊情况：

• 如果第一个参数为NaN，则返回NaN。
• 如果第一个参数为无穷大，则返回相同符号的无穷大。
• 如果第一个参数为零，则返回相同符号的零。

API注释：

该方法对应于IEEE 754中定义的scaleB操作。

参数：

d - 要乘以二的幂的数字。

scaleFactor - 用于缩放d的2的幂

返回：

d × 2^scaleFactor

自：

1.6

scalb

             public static float scalb(float f, int scaleFactor)
            

返回f × 2^scaleFactor，四舍五入，如同由单个正确舍入的浮点乘法执行。如果结果的指数在Float.MIN_EXPONENT和Float.MAX_EXPONENT之间，则答案将被精确计算。如果结果的指数大于 Float.MAX_EXPONENT，则返回无穷大。请注意，如果结果是次正规的，则可能会丢失精度；也就是说，当scalb(x, n)为次正规时，scalb(scalb(x, n), -n)可能不等于x。当结果为非NaN时，结果与f具有相同的符号。

特殊情况：

• 如果第一个参数为NaN，则返回NaN。
• 如果第一个参数为无穷大，则返回相同符号的无穷大。
• 如果第一个参数为零，则返回相同符号的零。

API注释：

该方法对应于IEEE 754中定义的scaleB操作。

参数：

f - 要乘以二的幂的数字。

scaleFactor - 用于缩放f的2的幂

返回：

f × 2^scaleFactor

自：

1.6