java.lang.Math

Math 计算的参数基本包含 double、float、int、long 等类型，下面方法以 int 为例（非 int 为特殊参数）。

常用静态方法：

  1. int abs(int a) ：返回 a 的绝对值
  2. double ceil(double a) ：大于 a 的最小整数（向上取整）
  3. double floor(double a) ：小于 a 的最大整数（向下取整）
  4. int max(int a, int b)，min(int a, int b) ：返回 a, b 之间的较大或较小值
  5. double pow(double a, double b) ：返回 a 的 b 次幂 ab
  6. double random()：返回值为 0.0 到 1.0 的随机数
  7. long round(double a) ：四舍五入的 long 值
  8. int round(float a) ：四舍五入的 int 值
  9. double sqrt(double a) ：平方根
    1. public class MathTests {
    2.  public static void main(String[] args) {
    3.      System.out.println(Math.abs(-1)); // 1
    4.      System.out.println(Math.ceil(-1.8)); // -1.0
    5.      System.out.println(Math.floor(-1.8)); // -2.0
    6.      System.out.println(Math.pow(2.0, 3.0)); // 8.0
    7.      System.out.println(Math.random()); // 0.0 - 1.0 随机数
    8.      System.out.println(Math.random() * 10); // 1.0 - 10.0 随机数
    9.      System.out.println(Math.round(24.3)); // 24
    10.      System.out.println(Math.round(24.5F)); // 25
    11.      System.out.println(Math.sqrt(64.0)); // 8.0
    12.  }
    13. }

    java.util.Random

    专门用于生成随机数的类；使用java.lang.Math.random() 方法只能生成 double 类型的随机数，其原理是在底层创建了 Random 类调用了 nextDouble() 方法生成的一个 double 类型随机数。

java.util.Random 实例是线程安全的。 但是，跨线程并发使用同一个 java.util.Random 实例可能会遇到争用，从而导致性能不佳。考虑在多线程设计中使用 java.util.concurrent.ThreadLocalRandom 。

java.util.Random 实例不是加密安全的。 考虑改为使用 java.security.SecureRandom 来获取加密安全的伪随机数生成器，以供对安全敏感的应用程序使用。

常用方法：

  1. public class RandomTests {
  2.     public static void main(String[] args) {
  3.         Random rand = new Random();
  5.         // 1. 随机生成[0,1)之间的 double 类型的数据
  6.         System.out.println(rand.nextDouble());
  8.         // 2. 随机生成int类型允许范围之内的 int 数据
  9.         System.out.println(rand.nextInt());
  11.         // 3. 随机生成[0,1)之间的 float 类型的数据
  12.         System.out.println(rand.nextFloat());
  14.         // 4. 随机生成[false,true]的 boolean 类型数据
  15.         System.out.println(rand.nextBoolean());
  17.         // 随机生成[0,10)之间的 int 类型的数据
  18.         System.out.println(rand.nextInt(10));
  20.         // 随机生成[20,30)之间的 int 类型的数据
  21.         System.out.println(20 + rand.nextInt(10));
  23.         // 随机生成[20,30)之间的 int 类型的数据（此种方法计算较为复杂）
  24.         System.out.print(20 + (int) (rand.nextDouble() * 10));
  25.     }
  26. }

java.math.BigDecimal

  1. 浮点型运算的时候直接+ * / 可能会出现数据失真（精度问题）。
  2. BigDecimal 可以解决浮点型运算数据失真的精度问题。

引入：为什么要使用 BigDecimal？什么是精度丢失？

  1. System.out.println(0.2 + 0.1); // 0.30000000000000004
  2. System.out.println(0.3 - 0.1); // 0.19999999999999998
  3. System.out.println(0.2 * 0.1); // 0.020000000000000004
  4. System.out.println(0.3 / 0.1); // 2.9999999999999996

计算机只能识别二级制，在进行数学计算时，参与计算的数据都是二进制，所以我们输入的十进制计算数据都会先转换为二进制，计算机用二进制计算完成后，再由二进制转换为十进制返回。

在这过程中，十进制转二进制时，有些数字是无法完全转换的，小数在转换为二进制时并不一定能用一个精确的二进制表示，大多数时候都是取的一个近似值，这就造成了精度的丢失。如果再用这个二进制进行计算，明显计算结果的精度会进一步丢失。终极原因还是因为精度丢失。

浮点数二进制与十进制转换：https://www.bilibili.com/read/cv11242656/

针对这一问题，Java 语言提供了 java.math.BigDecimal 类专门用来进行精确计算。

阿里巴巴推荐创建对象方式

【强制】为了防止精度损失，禁止使用构造方法 BigDecimal(double) 的方式把 double 值转化为 BigDecimal 对象。

说明：BigDecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。
如：BigDecimal g = new BigDecimal(0.1f); 实际的存储值为：0.10000000149

正例：优先推荐入参为 String 的构造方法，或使用 BigDecimal 的 valueOf 方法，此方法内部其实执行了 Double 的 toString，而 Double 的 toString 按 double 的实际能表达的精度对尾数进行了截断。

  1. BigDecimal recommend1 = new BigDecimal("0.1");
  2. BigDecimal recommend2 = BigDecimal.valueOf(0.1);

算术操作

方法签名 方法描述
BigDecimal add(BigDecimal augend) 加法运算
BigDecimal subtract(BigDecimal subtrahend) 减法运算
BigDecimal multiply(BigDecimal multiplicand) 乘法运算
BigDecimal divide(BigDecimal divisor) 除法运算 
  1. public class BigDecimalTests {
  2.     public static void main(String[] args) {
  3.         BigDecimal a = new BigDecimal("10.0");
  4.         BigDecimal b = new BigDecimal("3.0");
  5.         System.out.println(a.add(b)); // 13.0
  6.         System.out.println(a.subtract(b)); // 7.0
  7.         System.out.println(a.multiply(b)); // 30.00
  8.         System.out.println(a.divide(b, 5, RoundingMode.HALF_UP)); // 3.33333
  9.     }
  10. }

除了上述的四个基本的算术操作方法外，每种运算都还有中两个参数的重载方法：

  • BigDecimal add(BigDecimal augend, MathContext mc)；
  • BigDecimal subtract(BigDecimal subtrahend, MathContext mc)；
  • BigDecimal multiply(BigDecimal multiplicand, MathContext mc)；
  • BigDecimal divide(BigDecimal divisor, MathContext mc)；

这个多出来的参数主要用来约束计算结果的精度和舍入操作的算法。

java.math 工具类

MathContext - 计算精度

java.math.MathContext 是数值运算的上下文配置：

  1. precision：用于操作的位数; 结果四舍五入到这个精度；
  2. roundingMode：一个 RoundingMode 对象，指定舍入操作的算法；

RoundingMode 是 java.math 包下的枚举类型，指定能够舍弃精度的数值运算的舍入行为。

RoundingMode - 舍入算法

java.math.RoundingMode 用于指定能够舍弃精度的数值运算的舍入行为。

枚举值 枚举描述
RoundingMode.UP 不论正负，进1法舍入，向远离 0 的方向舍入
RoundingMode.DOWN 舍弃小数部分，向靠近 0 的方向舍入
RoundingMode.CEILING 正数进1法(UP)，负数舍弃小数部分(DOWN)，向正无穷方向舍入
RoundingMode.FLOOR 正数舍弃小数部分(DOWN)，负数进1法(UP)，向负无穷方向舍入
RoundingMode.HALF_UP 四舍五入法，大于等于5时进1，否则舍弃，向最近邻居的方向舍入
RoundingMode.HALF_DOWN 五舍六入，大于5时进1位，否则舍弃，向最近邻居的方向舍入
RoundingMode.HALF_EVEN 距离相等时向偶数邻居舍入，向最近邻居的方向舍入，银行家的四舍五入
RoundingMode.UNNECESSARY 不舍入 
  1. public enum RoundingMode {
  3.     /**
  4.      *  5.5         6
  5.      *  2.5         3
  6.      *  1.6         2
  7.      *  1.1         1
  8.      *  1.0         1
  9.      * -1.0        -1
  10.      * -1.1        -2
  11.      * -1.6        -2
  12.      * -2.5        -3
  13.      * -5.5        -6
  14.      */
  15.     UP(BigDecimal.ROUND_UP),
  16.     /**
  17.      *  5.5         5
  18.      *  2.5         2
  19.      *  1.6         1
  20.      *  1.1         1
  21.      *  1.0         1
  22.      * -1.0        -1
  23.      * -1.1        -1
  24.      * -1.6        -1
  25.      * -2.5        -2
  26.      * -5.5        -5
  27.      */
  28.     DOWN(BigDecimal.ROUND_DOWN),
  30.     /**
  31.      *  5.5         6
  32.      *  2.5         3
  33.      *  1.6         2
  34.      *  1.1         2
  35.      *  1.0         1
  36.      * -1.0        -1
  37.      * -1.1        -1
  38.      * -1.6        -1
  39.      * -2.5        -2
  40.      * -5.5        -5
  41.      */
  42.     CEILING(BigDecimal.ROUND_CEILING),
  44.      /**
  45.      *  5.5         5
  46.      *  2.5         2
  47.      *  1.6         1
  48.      *  1.1         1
  49.      *  1.0         1
  50.      * -1.0        -1
  51.      * -1.1        -2
  52.      * -1.6        -2
  53.      * -2.5        -3
  54.      * -5.5        -6
  55.      */
  56.     FLOOR(BigDecimal.ROUND_FLOOR),
  58.     /**
  59.      *  5.5         6
  60.      *  2.5         3
  61.      *  1.6         2
  62.      *  1.1         1
  63.      *  1.0         1
  64.      * -1.0        -1
  65.      * -1.1        -1
  66.      * -1.6        -2
  67.      * -2.5        -3
  68.      * -5.5        -6
  69.      */
  70.     HALF_UP(BigDecimal.ROUND_HALF_UP),
  72.     /**
  73.      *  5.5         5
  74.      *  2.5         2
  75.      *  1.6         2
  76.      *  1.1         1
  77.      *  1.0         1
  78.      * -1.0        -1
  79.      * -1.1        -1
  80.      * -1.6        -2
  81.      * -2.5        -2
  82.      * -5.5        -5
  83.      */
  84.     HALF_DOWN(BigDecimal.ROUND_HALF_DOWN),
  86.     /**
  87.      *  5.5         6
  88.      *  2.5         2
  89.      *  1.6         2
  90.      *  1.1         1
  91.      *  1.0         1
  92.      * -1.0        -1
  93.      * -1.1        -1
  94.      * -1.6        -2
  95.      * -2.5        -2
  96.      * -5.5        -6
  97.      */
  98.     HALF_EVEN(BigDecimal.ROUND_HALF_EVEN),
  100.     /**
  101.      *  5.5         抛出ArithmeticExceptio
  102.      *  2.5         抛出ArithmeticExceptio
  103.      *  1.6         抛出ArithmeticExceptio
  104.      *  1.1         抛出ArithmeticExceptio
  105.      *  1.0         1
  106.      * -1.0        -1
  107.      * -1.1         抛出ArithmeticExceptio
  108.      * -1.6         抛出ArithmeticExceptio
  109.      * -2.5         抛出ArithmeticExceptio
  110.      * -5.5         抛出ArithmeticExceptio
  111.      */
  112.     UNNECESSARY(BigDecimal.ROUND_UNNECESSARY);
  113. }

参考： JDK 源码 Java 8 API：https://www.matools.com/api/java8 舍入操作：https://www.cnblogs.com/yezi-lu/p/9448864.html 用法：https://blog.csdn.net/qq_33619378/article/details/90408110