Module java.base

Package java.lang

Class StrictMath

java.lang.Object

java.lang.StrictMath

       public final class StrictMath extends Object
      

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

为了确保Java程序的可移植性，此包中一些数值函数的定义要求它们产生与某些已发布算法相同的结果。这些算法可以从著名的网络库netlib中获取，作为包“Freely Distributable Math Library”，fdlibm。这些算法是用C编程语言编写的，然后应理解为将其转译为Java，并使用所有浮点和整数操作遵循Java算术规则执行。在转译中使用以下转换：

• 在C中提取和设置64位double的高位和低位使用Java平台方法表达，这些方法执行位转换从double到long和long到double。
• C中的无符号int值映射到Java中的有符号int值，并更新操作以复制无符号语义，其中在相同文本操作上的结果不同。例如，C中的无符号值的>>移位替换为Java中有符号值的>>>移位。对无符号C值的大小比较（<，<=，>，>=）替换为语义上等效的调用compareUnsigned。

Java数学库是相对于fdlibm版本5.3定义的。在fdlibm为函数提供多个定义（例如acos）时，使用“IEEE 754核心函数”版本（文件名以字母e开头） 。需要fdlibm语义的方法包括sin、cos、tan、asin、acos、atan、exp、log、log10、cbrt、atan2、pow、sinh、cosh、tanh、hypot、expm1和log1p。

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

IEEE 754推荐操作

Math类讨论了选定的Math和StrictMath方法的共享实现标准标准与IEEE 754推荐操作的关系。

自：

1.3

参见：

• IEEE浮点算术标准

Field Summary

Fields

Modifier and Type	Field	Description
static final double	E	距离自然对数的底数e最接近的double值。
static final double	PI	距离圆周与直径之比的圆周率pi（π）最接近的double值。
static final double	TAU	距离圆周与半径之比的圆周率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)	返回double值的自然数e的幂。
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)	计算 ( x 2 + y 2) ，无中间溢出或下溢。
static double	IEEEremainder(double f1, double f2)	根据IEEE 754标准规定，在两个参数上执行余数运算。
static int	incrementExact(int a)	返回参数加一的值，如果结果溢出int，则抛出异常。
static long	incrementExact(long a)	返回参数加一的值，如果结果溢出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。
• 如果参数为零，则结果为与参数相同符号的零。

参数:

a - 以弧度表示的角度。

返回:

参数的正弦值。

cos

             public static double cos(double a)
            

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

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

参数:

a - 以弧度表示的角度。

返回:

参数的余弦值。

tan

             public static double tan(double a)
            

返回角的三角正切值。特殊情况：

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

参数:

a - 以弧度表示的角度。

返回:

参数的正切值。

asin

             public static double asin(double a)
            

返回值的反正弦；返回的角度范围为-pi/2到pi/2。特殊情况：

• 如果参数为NaN或其绝对值大于1，则结果为NaN。
• 如果参数为零，则结果为与参数相同符号的零。

参数:

a - 要返回其反正弦的值。

返回:

参数的反正弦值。

acos

             public static double acos(double a)
            

返回值的反余弦；返回的角度范围为0.0到pi。特殊情况：

• 如果参数为NaN或其绝对值大于1，则结果为NaN。
• 如果参数为1.0，则结果为正零。

参数:

a - 要返回其反余弦的值。

返回:

参数的反余弦值。

atan

             public static double atan(double a)
            

返回值的反正切；返回的角度范围为-pi/2到pi/2。特殊情况：

• 如果参数为NaN，则结果为NaN。
• 如果参数为零，则结果为与参数相同符号的零。
• 如果参数为无穷大，则结果为与输入相同符号的最接近pi/2的值。

参数:

a - 要返回其反正切的值。

返回:

参数的反正切值。

toRadians

             public static double toRadians(double angdeg)
            

将以度表示的角度转换为近似等效的以弧度表示的角度。从度到弧度的转换通常是不精确的。

参数:

angdeg - 以度为单位的角度

返回:

以弧度表示的角度angdeg的测量值。

toDegrees

             public static double toDegrees(double angrad)
            

将以弧度表示的角度转换为近似等效的以度表示的角度。从弧度到度的转换通常是不精确的；用户不应期望cos(toRadians(90.0))精确等于0.0。

参数:

angrad - 以弧度为单位的角度

返回:

以度表示的角度angrad的测量值。

exp

             public static double exp(double a)
            

返回e的double值的幂。特殊情况：

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

参数:

a - 要将e提高到的指数。

返回:

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

log

             public static double log(double a)
            

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

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

参数:

a - 一个值

返回:

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

log10

             public static double log10(double a)
            

返回double值的十进制对数。特殊情况：

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

参数：

a - 一个值

返回：

a的十进制对数。

自版本：

1.5

sqrt

             public static double sqrt(double a)
            

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

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

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

参数：

a - 一个值。

返回：

a的正平方根。

cbrt

             public static double cbrt(double a)
            

返回double值的立方根。对于正有限x，cbrt(-x) == -cbrt(x)；即，负值的立方根是该值绝对值的负立方根。特殊情况：

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

参数：

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，则结果为负零。

注意，StrictMath.ceil(x)的值正好等于-StrictMath.floor(-x)的值。

参数：

a - 一个值。

返回：

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

floor

             public static double floor(double a)
            

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

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

参数：

a - 一个值。

返回：

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

rint

             public static double rint(double a)
            

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

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

参数：

a - 一个值。

返回：

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

atan2

             public static double atan2(double y, double x)
            

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

• 如果任一参数为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值。

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的固定点，则将其视为整数。如果一个值是一个一元方法的固定点，当且仅当将该方法应用于该值的结果等于该值时，该值是一个固定点。）

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

此后，此新的伪随机数生成器用于所有对此方法的调用，而且不用于其他任何地方。

此方法被正确同步，以允许多个线程正确使用。但是，如果许多线程需要以很高的速率生成伪随机数，则每个线程拥有自己的伪随机数生成器可能会减少对每个线程的争用。

返回：

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

参见：

• Random.nextDouble()

addExact

             public static int addExact(int x, int y)
            

返回其参数的和，如果结果溢出int，则抛出异常。

参数：

x - 第一个值

y - 第二个值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个int

自：

1.8

参见：

• Math.addExact(int,int)

addExact

             public static long addExact(long x, long y)
            

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

参数：

x - 第一个值

y - 第二个值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个long

自：

1.8

参见：

• Math.addExact(long,long)

subtractExact

             public static int subtractExact(int x, int y)
            

返回其参数的差，如果结果溢出int，则抛出异常。

参数：

x - 第一个值

y - 从第一个值中减去的第二个值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个int

自：

1.8

参见：

• Math.subtractExact(int,int)

subtractExact

             public static long subtractExact(long x, long y)
            

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

参数：

x - 第一个值

y - 从第一个值中减去的第二个值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个long

自：

1.8

参见：

• Math.subtractExact(long,long)

multiplyExact

             public static int multiplyExact(int x, int y)
            

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

参数：

x - 第一个值

y - 第二个值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个int

自：

1.8

参见：

• Math.multiplyExact(int,int)

multiplyExact

             public static long multiplyExact(long x, int y)
            

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

参数:

x - 第一个值

y - 第二个值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出long

自版本:

9

参见:

• Math.multiplyExact(long,int)

multiplyExact

             public static long multiplyExact(long x, long y)
            

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

参数:

x - 第一个值

y - 第二个值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出long

自版本:

1.8

参见:

• Math.multiplyExact(long,long)

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 Division Operator /

自版本:

18

参见:

• Math.divideExact(int,int)

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 Division Operator /

自版本:

18

参见:

• Math.divideExact(long,long)

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)方法。

有关示例和与整数除法/运算符的比较，请参见Math.floorDiv。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

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

自版本:

18

参见:

• Math.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)方法。

有关示例，请参见Math.floorDiv。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

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

自版本:

18

参见:

• Math.floorDiv(int, int)
• Math.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)方法。

有关示例和与整数除法/运算符的比较，请参见Math.ceilDiv。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

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

自版本:

18

参见:

• Math.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)方法。

有关示例，请参见Math.ceilDiv。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

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

自版本:

18

参见:

• Math.ceilDiv(int, int)
• Math.ceilDiv(long,long)

incrementExact

             public static int incrementExact(int a)
            

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

参数:

a - 要递增的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出int

自:

14

参见:

• Math.incrementExact(int)

incrementExact

             public static long incrementExact(long a)
            

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

参数:

a - 要递增的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出long

自:

14

参见:

• Math.incrementExact(long)

decrementExact

             public static int decrementExact(int a)
            

返回递减了一的参数，如果结果溢出int则抛出异常。溢出仅发生在最小值时。

参数:

a - 要递减的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出int

自:

14

参见:

• Math.decrementExact(int)

decrementExact

             public static long decrementExact(long a)
            

返回递减了一的参数，如果结果溢出long则抛出异常。溢出仅发生在最小值时。

参数:

a - 要递减的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出long

自:

14

参见:

• Math.decrementExact(long)

negateExact

             public static int negateExact(int a)
            

返回参数的否定值，如果结果溢出int则抛出异常。溢出仅发生在最小值时。

参数:

a - 要取反的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出int

自:

14

参见:

• Math.negateExact(int)

negateExact

             public static long negateExact(long a)
            

返回参数的否定值，如果结果溢出long则抛出异常。溢出仅发生在最小值时。

参数:

a - 要取反的值

返回:

结果

抛出:

ArithmeticException - 如果结果溢出long

自:

14

参见:

• Math.negateExact(long)

toIntExact

             public static int toIntExact(long value)
            

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

参数:

value - long值

返回:

作为int的参数

抛出:

ArithmeticException - 如果参数溢出int

自:

1.8

参见:

• Math.toIntExact(long)

multiplyFull

             public static long multiplyFull(int x, int y)
            

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

参数:

x - 第一个值

y - 第二个值

返回:

结果

自:

9

参见:

• Math.multiplyFull(int,int)

multiplyHigh

             public static long multiplyHigh(long x, long y)
            

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

参数:

x - 第一个值

y - 第二个值

返回:

结果

自:

9

参见:

• unsignedMultiplyHigh(long, long)
• Math.multiplyHigh(long,long)

unsignedMultiplyHigh

             public static long unsignedMultiplyHigh(long x, long y)
            

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

参数:

x - 第一个值

y - 第二个值

返回:

结果

自:

18

参见:

• multiplyHigh(long, long)
• Math.unsignedMultiplyHigh(long,long)

floorDiv

             public static int floorDiv(int x, int y)
            

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

参见Math.floorDiv以获取示例和与整数除法/运算符的比较。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

ArithmeticException - 如果除数y为零

自:

1.8

参见:

• Math.floorDiv(int, int)
• Math.floor(double)

floorDiv

             public static long floorDiv(long x, int y)
            

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

参见Math.floorDiv以获取示例和与整数除法/运算符的比较。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

ArithmeticException - 如果除数y为零

自:

9

参见:

• Math.floorDiv(long, int)
• Math.floor(double)

floorDiv

             public static long floorDiv(long x, long y)
            

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

参见Math.floorDiv以获取示例和与整数除法/运算符的比较。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

ArithmeticException - 如果除数y为零

自:

1.8

参见:

• Math.floorDiv(long, long)
• Math.floor(double)

floorMod

             public static int floorMod(int x, int y)
            

返回int参数的地板模数。

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

floorDiv和floorMod之间的关系是：floorDiv(x, y) * y + floorMod(x, y) == x

参见Math.floorMod以获取示例和与%运算符的比较。

参数:

x - 被除数

y - 除数

返回:

地板取模 x - (floorDiv(x, y) * y)

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

1.8

参见:

• Math.floorMod(int, int)
• 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

参见 Math.floorMod 获取示例和与 % 运算符的比较。

参数:

x - 被除数

y - 除数

返回:

地板取模 x - (floorDiv(x, y) * y)

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

9

参见:

• Math.floorMod(long, int)
• 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

参见 Math.floorMod 获取示例和与 % 运算符的比较。

参数:

x - 被除数

y - 除数

返回:

地板取模 x - (floorDiv(x, y) * y)

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

1.8

参见:

• Math.floorMod(long, long)
• floorDiv(long, long)

ceilDiv

             public static int ceilDiv(int x, int y)
            

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

参见 Math.ceilDiv 获取示例和与整数除法 / 运算符的比较。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

18

参见:

• Math.ceilDiv(int, int)
• Math.ceil(double)

ceilDiv

             public static long ceilDiv(long x, int y)
            

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

参见 Math.ceilDiv 获取示例和与整数除法 / 运算符的比较。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

18

参见:

• Math.ceilDiv(long, int)
• Math.ceil(double)

ceilDiv

             public static long ceilDiv(long x, long y)
            

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

参见 Math.ceilDiv 获取示例和与整数除法 / 运算符的比较。

参数:

x - 被除数

y - 除数

返回:

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

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

18

参见:

• Math.ceilDiv(long, long)
• Math.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

参见 Math.ceilMod 获取示例和与 % 运算符的比较。

参数:

x - 被除数

y - 除数

返回:

天花板取模 x - (ceilDiv(x, y) * y)

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

18

参见:

• Math.ceilMod(int, int)
• 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

参见 Math.ceilMod 获取示例和与 % 运算符的比较。

参数:

x - 被除数

y - 除数

返回:

天花板取模 x - (ceilDiv(x, y) * y)

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

18

参见:

• Math.ceilMod(long, int)
• 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

参见 Math.ceilMod 获取示例和与 % 运算符的比较。

参数:

x - 被除数

y - 除数

返回:

天花板取模 x - (ceilDiv(x, y) * y)

抛出:

ArithmeticException - 如果除数 y 为零

自版本:

18

参见:

• Math.ceilMod(long, long)
• ceilDiv(long, long)

abs

             public static int abs(int a)
            

返回 int 值的绝对值。如果参数不为负数，则返回参数。如果参数为负数，则返回参数的取反。

请注意，如果参数等于 Integer.MIN_VALUE 的值，即最负的可表示的

参数:

a - 要确定绝对值的参数。

返回:

参数的绝对值。

参见:

• Math.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

参见:

• Math.abs(int)
• Math.absExact(int)

abs

             public static long abs(long a)
            

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

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

参数:

a - 要确定绝对值的参数。

返回:

参数的绝对值。

参见:

• Math.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

参见:

• Math.abs(long)
• Math.absExact(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。与数值比较运算符不同，此方法认为负零严格小于正零。如果一个参数是正零，另一个是负零，则结果是正零。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较大的值。

max

             public static double max(double a, double b)
            

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

参数:

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。与数值比较运算符不同，此方法认为负零严格小于正零。如果一个参数是正零，另一个是负零，则结果是负零。

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较小的值。

min

             public static double min(double a, double b)
            

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

参数:

a - 一个参数。

b - 另一个参数。

返回:

a和b中较小的值。

clamp

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

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

虽然长整型的原始值可能不适合整型，但边界具有整型，因此结果始终适合整型。这允许使用该方法将长整型值安全地转换为整型并进行饱和处理。

参数:

value - 要夹紧的值

min - 允许的最小值

max - 允许的最大值

返回:

一个夹紧在min..max区间内的值

抛出:

IllegalArgumentException - 如果min > max

自版本:

21

clamp

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

将值夹紧在min和max之间。如果值小于min，则返回min。如果值大于max，则返回max。否则，返回原始值。

参数:

value - 要夹紧的值

min - 允许的最小值

max - 允许的最大值

返回:

一个夹紧在min..max区间内的值

抛出:

IllegalArgumentException - 如果min > max

自版本:

21

clamp

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

将值夹紧在min和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。

自版本:

21

clamp

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

将值夹紧在min和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。

自版本:

21

fma

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

返回三个参数的融合乘加；即返回第一个两个参数的精确乘积与第三个参数相加，然后将结果四舍五入到最接近的double。四舍五入使用最接近偶数舍入模式。相比之下，如果a * b + c作为常规浮点表达式计算，涉及两个舍入误差，一个用于乘法操作，另一个用于加法操作。

特殊情况：

• 如果任一参数为NaN，则结果为NaN。
• 如果前两个参数中有一个是无穷大，另一个是零，则结果为NaN。
• 如果前两个参数的精确乘积为无穷大（换句话说，至少一个参数是无穷大，另一个既不是零也不是NaN），且第三个参数是相反符号的无穷大，则结果为NaN。

请注意，fusedMac(a, 1.0, c) 返回与（a + c）相同的结果。然而，fusedMac(a, b, +0.0) 不总是返回与（a * b）相同的结果，因为fusedMac(-0.0, +0.0, +0.0) 是+0.0，而（-0.0 * +0.0）是-0.0；fusedMac(a, b, -0.0) 等同于（a * b）。

API注释:

此方法对应于IEEE 754-2008中定义的fusedMultiplyAdd操作。

参数:

a - 一个值

b - 一个值

c - 一个值

返回:

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

自版本:

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-2008中定义的fusedMultiplyAdd操作。

参数:

a - 一个值

b - 一个值

c - 一个值

返回:

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

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

特殊情况：

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

参数:

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

返回:

参数的符号函数

自版本:

1.5

signum

             public static float signum(float f)
            

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

特殊情况：

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

参数:

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

返回:

参数的符号函数

自版本:

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。

参数:

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。

参数:

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

返回:

x的双曲正切值。

自版本:

1.5

hypot

             public static double hypot(double x, double y)
            

返回sqrt(x² +y²)，避免中间溢出或下溢。

特殊情况：

• 如果任一参数是无穷大，则结果为正无穷。
• 如果任一参数是NaN且两个参数都不是无穷大，则结果为NaN。
• 如果两个参数都是零，则结果为正零。

参数:

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

参数:

x - 在计算ex -1时要将e提高到的指数。

返回:

值ex - 1。

自版本:

1.5

log1p

             public static double log1p(double x)
            

返回参数和1的自然对数之和。请注意，对于小值x，log1p(x)的结果比浮点数评估的log(1.0+x)更接近ln(1 + x)的真实结果。

特殊情况：

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

参数:

x - 一个值

返回:

值ln(x + 1)，x + 1的自然对数

自版本:

1.5

copySign

             public static double copySign(double magnitude, double sign)
            

返回第一个浮点参数与第二个浮点参数的符号相同。对于此方法，NaN的sign参数始终被视为正数。

参数:

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

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

返回:

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

自版本:

1.6

copySign

             public static float copySign(float magnitude, float sign)
            

返回第一个浮点参数与第二个浮点参数的符号相同。对于此方法，NaN的sign参数始终被视为正数。

参数:

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相同符号的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

参数:

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

特殊情况:

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

参数:

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。
• 如果第一个参数为无穷大，则返回相同符号的无穷大。
• 如果第一个参数为零，则返回相同符号的零。

参数:

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

scaleFactor - 用于缩放f的2的幂

返回:

f × 2^scaleFactor

自版本:

1.6