模块 java.base

包 java.lang

类 StrictMath

java.lang.Object

java.lang.StrictMath

public final class StrictMath extends Object 
      

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

为了帮助确保 Java 程序的可移植性，此包中某些数字函数的定义要求它们产生与某些已发布算法相同的结果。这些算法可以从著名的网络库 netlib 中作为“可自由分发的数学库”包 fdlibm 获得。这些算法是用 C 编程语言编写的，因此可以理解为按照 Java 浮点运算规则执行所有浮点运算。

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	描述
static final double	E	double 值比任何其他值都更接近e, 自然对数的底数。
static final double	PI	double 值比任何其他值都更接近pi(π)，圆的周长与其直径的比值。
static final double	TAU	double 值比任何其他值都更接近头(τ)，圆的周长与其半径之比。

方法总结

修饰符和类型	方法	描述
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)	返回角度theta从直角坐标 (x , y ) 到极坐标 (r,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	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)	返回平方根（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)	返回自然对数（基数e) 的 double 值。
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)	以 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 值。
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)	以 long 形式返回两个无符号 64 位因数的无符号 128 位乘积的最高 64 位。

在类 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(π)，圆的周长与其直径的比值。

参见：

• 常量字段值

TAU

public static final double TAU
            

double 值比任何其他值都更接近头(τ)，圆的周长与其半径之比。

API 注意：

的值pi是的一半头;换句话说，头是双pi .

自从：

19

参见：

• 常量字段值

方法详情

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)
            

将以弧度测量的角度转换为近似等效的以度测量的角度。从弧度到度的转换通常是不准确的；用户应该not期望 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)
            

返回自然对数（基数e的 double 值。特别案例：

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

参数：

a - 一个值

返回：

值 ln a ， a 的自然对数。

log10

public static double log10(double a)
            

返回 double 值的以 10 为底的对数。特别案例：

• 如果参数为 NaN 或小于零，则结果为 NaN。
• 如果参数为正无穷大，则结果为正无穷大。
• 如果参数为正零或负零，则结果为负无穷大。
• 如果参数等于 10ⁿ对于整数n, 那么结果是n.特别是，如果参数是 1.0 (10⁰)，则结果为正零。

参数：

a - 一个值

返回：

a 的以 10 为底的对数。

自从：

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)
            

返回角度theta从直角坐标 (x , y ) 到极坐标 (r,theta).该方法计算相位theta通过计算 y/x 在 - 范围内的反正切pi到pi.特别案例：

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

API 注意：

为了y具有正号和有限非零xatan2 的精确数学值等于：

• 如果x> 0，阿坦（绝对值（y/x))
• 如果x< 0, π - atan(abs(y/x))

参数：

y - 纵坐标

x——横坐标

返回：

这theta点的组件（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 的不动点时，浮点值才被认为是整数。一个值是一个不动点单参数方法的当且仅当将该方法应用于值的结果等于该值。）

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

自从：

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

自从：

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

自从：

9

参见：

• Math.multiplyExact(long,int)

multiplyExact

public static long multiplyExact(long x, long y)
            

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

参数：

x - 第一个值

y - 第二个值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出很长

自从：

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 除法运算符 /

自从：

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 为零或商溢出很长

看Java 语言规范:

15.17.2 除法运算符 /

自从：

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 。

ceil 模数方法 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 。

ceil 模数方法 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)
            

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

参数：

a - 要增加的值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个 int

自从：

14

参见：

• Math.incrementExact(int)

incrementExact

public static long incrementExact(long a)
            

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

参数：

a - 要增加的值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出很长

自从：

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

自从：

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

自从：

14

参见：

• Math.negateExact(long)

toIntExact

public static int toIntExact(long value)
            

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

参数：

value - 长值

返回：

作为 int 的参数

抛出：

ArithmeticException - 如果 argument 溢出一个 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)
            

以 long 形式返回两个 64 位因子的 128 位乘积的最高 64 位。

参数：

x - 第一个值

y - 第二个值

返回：

结果

自从：

9

参见：

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

unsignedMultiplyHigh

public static long unsignedMultiplyHigh(long x, long y)
            

以 long 形式返回两个无符号 64 位因数的无符号 128 位乘积的最高 64 位。

参数：

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 的值，即最负的可表示 int 值，则结果是相同的值，即负数。相反，absExact(int) 方法为此值抛出一个 ArithmeticException。

参数：

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 中较小的一个。

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) not 总是返回与 (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) 确实 not 总是返回与 (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 值之间的正距离。请注意，对于非 NaNx, 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 值之间的正距离。请注意，对于非 NaNx, 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)
            

返回平方根（x² +y²) 没有中间溢出或下溢。

特别案例：

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

参数：

x - 一个值

y - 一个值

返回：

开方（x² +y²) 无中间溢出或下溢

自从：

1.5

expm1

public static double expm1(double x)
            

返回e^x-1。请注意，对于值x接近 0，expm1(x) + 1 的精确和更接近真实结果e^x比exp(x)。

特别案例：

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

参数：

x - 要提高的指数e在计算中e^x -1.

返回：

值e^x - 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 的值

返回：

direction 方向上与 start 相邻的浮点数。

自从：

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 的值

返回：

direction 方向上与 start 相邻的浮点数。

自从：

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 - 要按 2 的幂缩放的数字。

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 - 要按 2 的幂缩放的数字。

scaleFactor - 用于缩放 f 的 2 的幂

返回：

f×2^scaleFactor

自从：

1.6