java解析硬件数据报文工具类_Java 工具类总结(1): 使基本数值计算更简单 - Math

1. Math 类说明

/**

* 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

2. 常用的常量与方法

2.1 常量

/**

* 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;

2.2 常用方法

都是类方法, 可以直接通过类调用, 例如: Math.abs(double d);

第一组: ceil() / floor() / rint() / round()

/**

* 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() : 四舍五入, 不推荐使用; (暂时不太明白, 为什么会出现上面的结果)

第二组: random()

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

2.3 案例分析

todo…

2.4 所有类方法

类方法简洁说明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.RandomNumberGeneratorHolderjava.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.negativeZeroFloatBitsjava.lang.Math.negativeZeroDoubleBitsjava.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.twoToTheDoubleScaleUpjava.lang.Math.twoToTheDoubleScaleDownjava.lang.Math.powerOfTwoD(int)java.lang.Math.powerOfTwoF(int)