模块 java.base

包 java.lang

类 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 推荐操作

IEEE 754 浮点标准的 2019 修订版包括推荐操作的一部分以及这些操作的语义（如果它们包含在编程环境中）。此类中推荐的操作包括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	描述
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。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 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。
• 如果参数为零，则结果为零，符号与参数相同。
• 如果参数是 无穷 ，那么结果是最接近的值pi/2 与输入符号相同。

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

参数：

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

返回：

参数的反正切。

toRadians

public static double toRadians(double angdeg)
            

将以度为单位的角度转换为近似等效的以弧度为单位的角度。从度数到弧度的转换通常是不准确的。

参数：

angdeg - 一个角度，以度为单位

返回：

以弧度为单位测量角度 angdeg。

自从：

1.2

toDegrees

public static double toDegrees(double angrad)
            

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

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

• 如果参数为 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 中定义的平方根运算。

参数：

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 值。如果作为数学整数的两个 double 值同样接近，则结果是偶数的整数值。特别案例：

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

API 注意：

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

参数：

a - 一个 double 值。

返回：

最接近 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.

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

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

计算结果必须在精确结果的 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 - 如果结果溢出很长

自从：

1.8

subtractExact

public static int subtractExact(int x, int y)
            

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

参数：

x - 第一个值

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

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个 int

自从：

1.8

subtractExact

public static long subtractExact(long x, long y)
            

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

参数：

x - 第一个值

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

返回：

结果

抛出：

ArithmeticException - 如果结果溢出很长

自从：

1.8

multiplyExact

public static int multiplyExact(int x, int y)
            

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

参数：

x - 第一个值

y - 第二个值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个 int

自从：

1.8

multiplyExact

public static long multiplyExact(long x, int y)
            

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

参数：

x - 第一个值

y - 第二个值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出很长

自从：

9

multiplyExact

public static long multiplyExact(long x, long y)
            

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

参数：

x - 第一个值

y - 第二个值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出很长

自从：

1.8

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

看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 。

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

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

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

参数：

a - 要增加的值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个 int

自从：

1.8

incrementExact

public static long incrementExact(long a)
            

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

参数：

a - 要增加的值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出很长

自从：

1.8

decrementExact

public static int decrementExact(int a)
            

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

参数：

a - 要减少的值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个 int

自从：

1.8

decrementExact

public static long decrementExact(long a)
            

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

参数：

a - 要减少的值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出很长

自从：

1.8

negateExact

public static int negateExact(int a)
            

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

参数：

a - 要取反的值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出一个 int

自从：

1.8

negateExact

public static long negateExact(long a)
            

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

参数：

a - 要取反的值

返回：

结果

抛出：

ArithmeticException - 如果结果溢出很长

自从：

1.8

toIntExact

public static int toIntExact(long value)
            

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

参数：

value - 长值

返回：

作为 int 的参数

抛出：

ArithmeticException - 如果 argument 溢出一个 int

自从：

1.8

multiplyFull

public static long multiplyFull(int x, int y)
            

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

参数：

x - 第一个值

y - 第二个值

返回：

结果

自从：

9

multiplyHigh

public static long multiplyHigh(long x, long y)
            

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

参数：

x - 第一个值

y - 第二个值

返回：

结果

自从：

9

参见：

• unsignedMultiplyHigh(long, long)

unsignedMultiplyHigh

public static long unsignedMultiplyHigh(long x, long y)
            

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

参数：

x - 第一个值

y - 第二个值

返回：

结果

自从：

18

参见：

• multiplyHigh(long, long)

floorDiv

public static int floorDiv(int x, int y)
            

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

正常整数除法在舍入到零舍入模式（截断）下运行。此操作改为在朝向负无穷大（下限）舍入模式下进行。当确切的商不是整数且为负时，下限舍入模式给出不同的截断结果。

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

参数：

x - 股息

y - 除数

返回：

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

抛出：

ArithmeticException - 如果除数 y 为零

自从：

1.8

参见：

• floorMod(int, int)
• floor(double)

floorDiv

public static long floorDiv(long x, int y)
            

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

正常整数除法在舍入到零舍入模式（截断）下运行。此操作改为在朝向负无穷大（下限）舍入模式下进行。当精确结果不是整数且为负数时，下限舍入模式会给出不同的截断结果。

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

参数：

x - 股息

y - 除数

返回：

小于或等于代数商的最大（最接近正无穷大）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。

正常整数除法在舍入到零舍入模式（截断）下运行。此操作改为在朝向负无穷大（下限）舍入模式下进行。当精确结果不是整数且为负数时，下限舍入模式会给出不同的截断结果。

有关示例，请参阅 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 参数的底部模数。

下限模数为 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) 中所述。

示例：

• 不管参数的符号如何，当 x % y 也为零时，floorMod (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 - 除数

返回：

地板模数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

参见：

• ceilDiv(long, long)

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

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) 确实 not 总是返回与 (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 中定义的 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 中定义的 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。
• 如果参数是无限的，那么结果是一个与参数同号的无穷大。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 2.5 ulps 以内。

参数：

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 的极限值的 ulp 的 1/2 以内，正确签名的 ±1.0 应该是回。

参数：

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

返回：

x 的双曲正切值。

自从：

1.5

hypot

public static double hypot(double x, double y)
            

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

特别案例：

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

计算结果必须在精确结果的 1 ulp 以内。如果一个参数保持不变，则结果在另一个参数中必须是半单调的。

参数：

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

计算结果必须在精确结果的 1 ulp 以内。结果必须是半单调的。 expm1 对于任何有限输入的结果必须大于或等于 -1.0 。请注意，一旦e^x 1 在极限值 -1 的 1/2 ulp 以内，应返回 -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。
• 如果参数为正无穷大，则结果为正无穷大。
• 如果参数为负一，则结果为负无穷大。
• 如果参数为零，则结果为零，符号与参数相同。

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

参数：

x - 一个值

返回：

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

自从：

1.5

copySign

public static double copySign(double magnitude, double sign)
            

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

API 注意：

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

参数：

magnitude - 提供结果大小的参数

sign - 提供结果符号的参数

返回：

大小为 magnitude 且符号为 sign 的值。

自从：

1.6

copySign

public static float copySign(float magnitude, float sign)
            

返回带有第二个浮点参数符号的第一个浮点参数。请注意，与 StrictMath.copySign 方法不同，此方法不需要将 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 的值

返回：

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

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

API 注意：

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

参数：

f - 要按 2 的幂缩放的数字。

scaleFactor - 用于缩放 f 的 2 的幂

返回：

f×2^scaleFactor

自从：

1.6