/**
* The class Math contains methods for performing basic
* numeric operations such as the elementary exponential, logarithm,
* Math 类提供基本的函数, 用于指数, 对数, 平方根, 三角运算.
*
* Unlike some of the numeric methods of class
* StrictMath, all implementations of the equivalent
* functions of class Math are not defined to return the
* bit-for-bit same results. This relaxation permits
* better-performing implementations where strict reproducibility is
* not required.
* 相比于 StrictMath 类, Math 类不需要保证高精度, 所以运算效率更高.
*
* @author unascribed
* @author Joseph D. Darcy
* @since JDK1.0
*/
From JavaSE 8 source code : Math.class
/**
* The double value that is closer than any other to
* e, the base of the natural logarithms.
* Math.E 是自然数 e 的近似值, 用于包含自然数的数值运算;
*/
public static final double E = 2.7182818284590452354;
/**
* The double value that is closer than any other to
* PI, the ratio of the circumference of a circle to its.
* Math.PI 是圆周率 PI 的近似值, 用于涉及曲线的相关的运算;
*/
public static final double PI = 3.14159265358979323846;
都是类方法, 可以直接通过类调用, 例如: Math.abs(double d);
/**
* Returns the smallest (closest to negative infinity)
* {@code double} value that is greater than or equal to the
* argument and is equal to a mathematical integer.
* 返回不小于 double 参数的整数中最小的值, 返回类型是 double;
*
* Special cases:
* - If the argument value is already equal to a
* mathematical integer, then the result is the same as the
* argument.
*
- If the argument is NaN or an infinity or
* positive zero or negative zero, then the result is the same as
*
- If the argument value is less than zero but
* greater than -1.0, then the result is negative zero.
* 如果 double 参数已经等于整数, 则返回值本身; 如果 double 参数是 NaN / 正无穷 / 负无穷, 则返回值本身;
* 如果 double 参数小于 0, 大于 -1, 则返回 0;
*
* Note that the value of {@code Math.ceil(x)} is exactly the
* value of {@code -Math.floor(-x)}.
* Math.ceil(x) 的作用与 -Math.floor(-x) 等效
*
* @param a a value.
* @return the smallest (closest to negative infinity)
* floating-point value that is greater than or equal to
* the argument and is equal to a mathematical integer.
*/
public static double ceil(double a) {
return StrictMath.ceil(a); // default impl. delegates to StrictMath
}
/**
* Returns the largest (closest to positive infinity)
* {@code double} value that is less than or equal to the
* argument and is equal to a mathematical integer. Special cases:
* - If the argument value is already equal to a
* mathematical integer, then the result is the same as the
* argument.
- If the argument is NaN or an infinity or
* positive zero or negative zero, then the result is the same as
* the argument.
* 相较于 ceil() 方法, floor() 方法是:
* 回不大于 double 参数的整数中最大的值, 返回类型是 double;
*
* @param a a value.
* @return the largest (closest to positive infinity)
* floating-point value that less than or equal to the argument
* and is equal to a mathematical integer.
*/
public static double floor(double a) {
return StrictMath.floor(a); // default impl. delegates to StrictMath
}
/**
* Returns the {@code double} value that is closest in value
* to the argument and is equal to a mathematical integer. If two
* {@code double} values that are mathematical integers are
* equally close, the result is the integer value that is even.
* 数学中的, 四舍五入方法;
*
* Special cases:
* - If the argument value is already equal to a mathematical
* integer, then the result is the same as the argument.
*
- If the argument is NaN or an infinity or positive zero or negative
* zero, then the result is the same as the argument.
* 同上
*
* @param a a {@code double} value.
* @return the closest floating-point value to {@code a} that is
* equal to a mathematical integer.
*/
public static double rint(double a) {
return StrictMath.rint(a); // default impl. delegates to StrictMath
}
/**
* Returns the closest {@code int} to the argument, with ties
* rounding to positive infinity.
* 四舍五入方法;
*
*
* Special cases:
*
- If the argument is NaN, the result is 0.
*
- If the argument is negative infinity or any value less than or
* equal to the value of {@code Integer.MIN_VALUE}, the result is
* equal to the value of {@code Integer.MIN_VALUE}.
*
- If the argument is positive infinity or any value greater than or
* equal to the value of {@code Integer.MAX_VALUE}, the result is
* equal to the value of {@code Integer.MAX_VALUE}.
*
* @param a a floating-point value to be rounded to an integer.
* @return the value of the argument rounded to the nearest
* {@code int} value.
* @see java.lang.Integer#MAX_VALUE
* @see java.lang.Integer#MIN_VALUE
*/
public static int round(float a) {
int intBits = Float.floatToRawIntBits(a);
int biasedExp = (intBits & FloatConsts.EXP_BIT_MASK)
>> (FloatConsts.SIGNIFICAND_WIDTH - 1);
int shift = (FloatConsts.SIGNIFICAND_WIDTH - 2
+ FloatConsts.EXP_BIAS) - biasedExp;
if ((shift & -32) == 0) { // shift >= 0 && shift < 32
// a is a finite number such that pow(2,-32) <= ulp(a) < 1
int r = ((intBits & FloatConsts.SIGNIF_BIT_MASK)
| (FloatConsts.SIGNIF_BIT_MASK + 1));
if (intBits < 0) {
r = -r;
}
// In the comments below each Java expression evaluates to the value
// the corresponding mathematical expression:
// (r) evaluates to a / ulp(a)
// (r >> shift) evaluates to floor(a * 2)
// ((r >> shift) + 1) evaluates to floor((a + 1/2) * 2)
// (((r >> shift) + 1) >> 1) evaluates to floor(a + 1/2)
return ((r >> shift) + 1) >> 1;
} else {
// a is either
// - a finite number with abs(a) < exp(2,FloatConsts.SIGNIFICAND_WIDTH-32) < 1/2
// - a finite number with ulp(a) >= 1 and hence a is a mathematical integer
// - an infinity or NaN
return (int) a;
}
}
/**
* Returns the closest {@code long} to the argument, with ties
* rounding to positive infinity.
* 四舍五入方法
* Special cases:
*
- If the argument is NaN, the result is 0.
*
- If the argument is negative infinity or any value less than or
* equal to the value of {@code Long.MIN_VALUE}, the result is
* equal to the value of {@code Long.MIN_VALUE}.
*
- If the argument is positive infinity or any value greater than or
* equal to the value of {@code Long.MAX_VALUE}, the result is
* equal to the value of {@code Long.MAX_VALUE}.
*
* @param a a floating-point value to be rounded to a
* {@code long}.
* @return the value of the argument rounded to the nearest
* {@code long} value.
* @see java.lang.Long#MAX_VALUE
* @see java.lang.Long#MIN_VALUE
*/
public static long round(double a) {
long longBits = Double.doubleToRawLongBits(a);
long biasedExp = (longBits & DoubleConsts.EXP_BIT_MASK)
>> (DoubleConsts.SIGNIFICAND_WIDTH - 1);
long shift = (DoubleConsts.SIGNIFICAND_WIDTH - 2
+ DoubleConsts.EXP_BIAS) - biasedExp;
if ((shift & -64) == 0) { // shift >= 0 && shift < 64
// a is a finite number such that pow(2,-64) <= ulp(a) < 1
long r = ((longBits & DoubleConsts.SIGNIF_BIT_MASK)
| (DoubleConsts.SIGNIF_BIT_MASK + 1));
if (longBits < 0) {
r = -r;
}
// In the comments below each Java expression evaluates to the value
// the corresponding mathematical expression:
// (r) evaluates to a / ulp(a)
// (r >> shift) evaluates to floor(a * 2)
// ((r >> shift) + 1) evaluates to floor((a + 1/2) * 2)
// (((r >> shift) + 1) >> 1) evaluates to floor(a + 1/2)
return ((r >> shift) + 1) >> 1;
} else {
// a is either
// - a finite number with abs(a) < exp(2,DoubleConsts.SIGNIFICAND_WIDTH-64) < 1/2
// - a finite number with ulp(a) >= 1 and hence a is a mathematical integer
// - an infinity or NaN
return (long) a;
}
}
演示 demo:
// 不小于 param 的最小整数
System.out.println(Math.ceil(2.3)); // 3.0
System.out.println(Math.ceil(2.7)); // 3.0
System.out.println(Math.ceil(-2.3)); // -2.0
System.out.println(Math.ceil(-2.7)); // -2.0
// 不大于 param 的最大整数
System.out.println(Math.floor(2.3)); // 2.0
System.out.println(Math.floor(2.7)); // 2.0
System.out.println(Math.floor(-2.3)); // -3.0
System.out.println(Math.floor(-2.7)); // -3.0
// 四舍五入: rint() / round(float) / round(double)
// rint() 注意点(暂时无法解释):
// 当小数点前一位是偶数的时候, 舍去小数位; 如, Math.rint(2.5) = 2.0
// 当小数点前一位是奇数的时候, 进一位; 如, Math.rint(3.5) = 4.0
// 暂时, 不推荐使用
System.out.println(Math.rint(2.5)); // 2.0
System.out.println(Math.rint(-2.5)); // -2.0
System.out.println(Math.rint(3.5)); // 4.0
System.out.println(Math.rint(-3.5)); // -4.0
//round(float)
// 暂时不推荐使用
System.out.println(Math.round(2.5f)); //3
System.out.println(Math.round(-2.5f)); //-2
System.out.println(Math.round(3.5f)); //4
System.out.println(Math.round(-3.5f)); //-3
System.out.println(Math.round(-4.5)); //-4
结论:
1. Math.floor() / Math.ceil(): 向下取整/ 向上取整;
2. Math.rint() / Math.round() : 四舍五入, 不推荐使用; (暂时不太明白, 为什么会出现上面的结果)
private static final class RandomNumberGeneratorHolder {
static final Random randomNumberGenerator = new Random();
}
/**
* Returns a {@code double} value with a positive sign, greater
* than or equal to {@code 0.0} and less than {@code 1.0}.
* Returned values are chosen pseudorandomly with (approximately)
* uniform distribution from that range.
* 返回一个返回在 [0.0, 1.0] 之间的伪随机数 double 类型;
*
* When this method is first called, it creates a single new
* pseudorandom-number generator, exactly as if by the expression
*
{@code new java.util.Random()}
* This new pseudorandom-number generator is used thereafter for
* all calls to this method and is used nowhere else.
*
*
This method is properly synchronized to allow correct use by
* more than one thread. However, if many threads need to generate
* pseudorandom numbers at a great rate, it may reduce contention
* for each thread to have its own pseudorandom-number generator.
* 当第一次调用 random() 方法的时候, 系统会生成一个伪随机类, 用于被所有的线程调用;
* 当线程较少的时候, 所有线程都会使用这个伪随机类生成随机数; 但是一旦访问密集的时候,
* 特定的线程就会重新生成自己的伪随机列;
*
* 总结: 此方法, 是线程安全的 (个人理解)
* @return a pseudorandom {@code double} greater than or equal
* to {@code 0.0} and less than {@code 1.0}.
* @see Random#nextDouble()
*/
public static double random() {
return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
}
显示 demo :
// 单线程演示
// random()
for(int i=0; i<10; ++i) {
System.out.println(Math.random());
}
// 多线程显示
// todo... ...
todo…
类方法 | 简洁说明 |
---|---|
java.lang.Math.sin(double) | |
java.lang.Math.cos(double) | |
java.lang.Math.tan(double) | |
java.lang.Math.asin(double) | |
java.lang.Math.acos(double) | |
java.lang.Math.atan(double) | |
java.lang.Math.toRadians(double) | |
java.lang.Math.toDegrees(double) | |
java.lang.Math.exp(double) | |
java.lang.Math.log(double) | |
java.lang.Math.log10(double) | |
java.lang.Math.sqrt(double) | |
java.lang.Math.cbrt(double) | |
java.lang.Math.IEEEremainder(double, double) | |
java.lang.Math.ceil(double) | 向上取整 |
java.lang.Math.floor(double) | 向下取整 |
java.lang.Math.rint(double) | |
java.lang.Math.atan2(double, double) | |
java.lang.Math.pow(double, double) | |
java.lang.Math.round(float) | |
java.lang.Math.round(double) | |
java.lang.Math.RandomNumberGeneratorHolder | |
java.lang.Math.random() | |
java.lang.Math.addExact(int, int) | |
java.lang.Math.addExact(long, long) | |
java.lang.Math.subtractExact(int, int) | |
java.lang.Math.subtractExact(long, long) | |
java.lang.Math.multiplyExact(int, int) | |
java.lang.Math.multiplyExact(long, long) | |
java.lang.Math.incrementExact(int) | |
java.lang.Math.incrementExact(long) | |
java.lang.Math.decrementExact(int) | |
java.lang.Math.decrementExact(long) | |
java.lang.Math.negateExact(int) | |
java.lang.Math.negateExact(long) | |
java.lang.Math.toIntExact(long) | |
java.lang.Math.floorDiv(int, int) | |
java.lang.Math.floorDiv(long, long) | |
java.lang.Math.floorMod(int, int) | |
java.lang.Math.floorMod(long, long) | |
java.lang.Math.abs(int) | |
java.lang.Math.abs(long) | |
java.lang.Math.abs(float) | |
java.lang.Math.abs(double) | |
java.lang.Math.max(int, int) | |
java.lang.Math.max(long, long) | |
java.lang.Math.negativeZeroFloatBits | |
java.lang.Math.negativeZeroDoubleBits | |
java.lang.Math.max(float, float) | |
java.lang.Math.max(double, double) | |
java.lang.Math.min(int, int) | |
java.lang.Math.min(long, long) | |
java.lang.Math.min(float, float) | |
java.lang.Math.min(double, double) | |
java.lang.Math.ulp(double) | |
java.lang.Math.ulp(float) | |
java.lang.Math.signum(double) | |
java.lang.Math.signum(float) | |
java.lang.Math.sinh(double) | |
java.lang.Math.cosh(double) | |
java.lang.Math.tanh(double) | |
java.lang.Math.hypot(double, double) | |
java.lang.Math.expm1(double) | |
java.lang.Math.log1p(double) | |
java.lang.Math.copySign(double, double ) | |
java.lang.Math.copySign(float, float) | |
java.lang.Math.getExponent(float) | |
java.lang.Math.getExponent(double) | |
java.lang.Math.nextAfter(double, double) | |
java.lang.Math.nextAfter(float, double) | |
java.lang.Math.nextUp(double) | |
java.lang.Math.nextUp(float) | |
java.lang.Math.nextDown(double) | |
java.lang.Math.nextDown(float) | |
java.lang.Math.scalb(double, int) | |
java.lang.Math.scalb(float, int) | |
java.lang.Math.twoToTheDoubleScaleUp | |
java.lang.Math.twoToTheDoubleScaleDown | |
java.lang.Math.powerOfTwoD(int) | |
java.lang.Math.powerOfTwoF(int) |