Java Math、BigDecimal和BigInteger类常用方法

￡神魔★判官ぃ 2021-11-27 07:02 380阅读 0赞

### 与数学相关的三个常用类 ###

**Math 类**：Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。都是静态方法，使用不多.

**BigDecimal 类**：float和double都不能表示精确的小数，此时使用 BigDecimal类，用于处理金钱和精度要求高的数据.

**BigInteger 类**：表示大整型，如果两个long类型的最大值相运算，结果long再也存储不下，此时使用BigInteger，一般不用.

### 一、Math 类 ###

有两个常量

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

方法等：

*   *  <table> 
         <tbody> 
          <tr> 
           <td><code>static double</code></td> 
           <td><code><a rel="nofollow">abs</a>(double&nbsp;a)</code> <p>返回值为 <code>double</code>绝对值。</p> </td> 
          </tr> 
          <tr> 
           <td><code>static double</code></td> 
           <td><code><a rel="nofollow">ceil</a>(double&nbsp;a)</code> <p>返回大于或等于参数的最小（最接近负无穷大） <code>double</code>值，等于一个数学整数。</p> </td> 
          </tr> 
          <tr> 
           <td><code>static double</code></td> 
           <td><code><a rel="nofollow">floor</a>(double&nbsp;a)</code> <p>返回小于或等于参数的最大（最接近正无穷大） <code>double</code>值，等于一个数学整数。</p> </td> 
          </tr> 
          <tr> 
           <td><code>static float</code></td> 
           <td><code><a rel="nofollow">max</a>(float&nbsp;a, float&nbsp;b)</code> <p>返回两个 <code>float</code>的较大值。</p> </td> 
          </tr> 
          <tr> 
           <td><code>static int</code></td> 
           <td><code><a rel="nofollow">min</a>(int&nbsp;a, int&nbsp;b)</code> <p>返回两个 <code>int</code>的较小值。</p> </td> 
          </tr> 
          <tr> 
           <td><code>static double</code></td> 
           <td><code><a rel="nofollow"><span style="color:#f33b45;">random</span></a><span style="color:#f33b45;">()</span></code> <p>返回值为 <code>double</code>值为正号，大于等于 <code>0.0</code> ，小于 <code>1.0</code> 。</p> </td> 
          </tr> 
          <tr> 
           <td><code>static double</code></td> 
           <td><code><a rel="nofollow"><span style="color:#f33b45;">rint</span></a><span style="color:#f33b45;">(double&nbsp;a)</span></code> <p>返回与参数最接近值的 <code>double</code>值，并且等于数学整数。</p> </td> 
          </tr> 
          <tr> 
           <td><code>static long</code></td> 
           <td><code><a rel="nofollow"><span style="color:#f33b45;">round</span></a><span style="color:#f33b45;">(double&nbsp;a)</span></code> <p>返回参数中最接近的 <code>long</code> ，其中 <code>long</code>四舍五入为正无穷大。</p> </td> 
          </tr> 
          <tr> 
           <td><code>static int</code></td> 
           <td><code><a rel="nofollow">round</a>(float&nbsp;a)</code> <p>返回参数中最接近的 <code>int</code> ，其中 <code>int</code>四舍五入为正无穷大。</p> </td> 
          </tr> 
         </tbody> 
        </table>

**测试 demo**

public static void main(String[] args) {
            /**
             *  Math.abs(); 求绝对值
             *  参数支持：double float 和int
             */
            System.out.println("绝对值：" + Math.abs(-10.5)); // 10.5
            System.out.println("绝对值：" + Math.abs(10.4));  // 10.4
    
            /**
             *  Math.max(); 求最大值
             *  Math.min(); 求最小值
             *  参数支持：double float long和int
             * */
            System.out.println("最大值：" + Math.max(100L, 99L));       // 100
            System.out.println("最小值：" + Math.min(-10.5f, -10.4f));  // -10.5
    
            /**
             *  Math.ceil(); 天花板的意思，返回向上取整数（取最大值）
             */
            System.out.println("值：" + Math.ceil(-10.1)); // -10
            System.out.println("值：" + Math.ceil(10.1));  // 11
    
             /**
             *  Math.floor(); 地板的意思，返回向下取整数（取最小值）
             */
            System.out.println("值：" + Math.floor(-10.1)); // -11
            System.out.println("值：" + Math.floor(10.1));  // 10
    
            /**
             * Math.random(); 返回一个在 [0,1) 内的随机数double值
             */
            System.out.println("[0,1)值：" + Math.random());     // 0.5498044946067191
            System.out.println("[49,100)值：" + (Math.random() * 51 + 49));  // 78.0217677789672
    
            /**
             * Math.rint(); 四舍五入
             * 返回double值
             */
            System.out.println("四舍五入值：" + Math.rint(-10.5)); // -10.0  
            System.out.println("四舍五入值：" + Math.rint(-10.51)); // -11  
            System.out.println("四舍五入值：" + Math.rint(10.4));  // 10.0
    
            /**
             * Math.round() 四舍五入
             * float时返回int值，double时返回long值
             */
            System.out.println("四舍五入值：" + Math.round(-10.5)); // -10
            System.out.println("四舍五入值：" + Math.round(-10.51)); // -11
            System.out.println("四舍五入值：" + Math.round(10.4f));  // 10
        }

### 二、BigDecimal 类 ###

Java 中提供了大数字(超过16位有效位)的操作类，即 java.math.BinInteger 类和 java.math.BigDecimal 类，用于高精度计算。其中：

BigInteger 类是针对大 整数的处理类，而 BigDecimal 类则是针对大 小数的处理类.

BigDecimal 类的实现用到了 BigInteger类，不同的是 BigDecimal 加入了小数的概念.

float 和 Double 只能用来做科学计算或者是工程计算；在商业计算中，对数字精度要求较高，必须使用 BigInteger 类和   BigDecimal 类,它支持任何精度的定点数，可以用它来精确计算货币值.

**BigDecimal 类创建的是对象，不能使用传统的+、-、\*、/等算术运算符直接对其进行数学运算，而必须调用其对应的方法。方法的参数也必须是BigDecimal类型的对象.**

**1、构造 BigDecimal 对象常用方法**

![20190724153609912.png][]

![20190724154101901.png][]

![20190724153750730.png][]

注意：

1）double 参数的构造方法，不允许使用！因为它不能精确的得到相应的值，值会变大;

2）String 构造方法是完全可预知的: 写入 new BigDecimal("0.1") 将创建一个 BigDecimal,它正好等于预期的0.1; 因此,通常建议优先使用 String 构造方法;

3） 静态方法 valueOf(double val) 内部实现，仍是将 double 类型转为 String 类型; 这通常是将 double(或float)转化为 BigDecimal 的首选方法;

4）  BigDecimal 类 覆写了 toString 方法

![2019072415514820.png][]

public static void main(String[] args) {
            double d1 = 0.1;
            double d2 = 100.1;
    
            // 此方式绝对不允许使用！
            System.out.println(new BigDecimal(d1)); // 0.1000000000000000055511151231257827021181583404541015625
            System.out.println(new BigDecimal(d2)); // 100.099999999999994315658113919198513031005859375
    
            System.out.println(new BigDecimal("0.1"));  // 0.1
            System.out.println(new BigDecimal("100.0"));// 100.1
    
            BigDecimal b1 = BigDecimal.valueOf(d1); // 0.1
            BigDecimal b2 = BigDecimal.valueOf(d2); // 100.1
            System.out.println(b1); // 0.1
            System.out.println(b2); // 100.1
    
            System.out.println(new BigDecimal(String.valueOf(d1)));  // 0.1
            System.out.println(new BigDecimal(String.valueOf(d2)));  // 100.1
            System.out.println(new BigDecimal(Double.toString(d1))); // 0.1
            System.out.println(new BigDecimal(Double.toString(d2))); // 100.1
        }

**1、简单加减乘等计算方法**

public static void main(String[] args) {
            double d1 = 0.2;
            double d2 = 100.2;
            BigDecimal b1 = BigDecimal.valueOf(d1); // 0.2
            BigDecimal b2 = BigDecimal.valueOf(d2); // 100.2
            /**
             * 精确计算
             */
            System.out.println(b1.add(b2));      // 加法 100.4
            System.out.println(b1.subtract(b2)); // 减法 -100.0
            System.out.println(b1.multiply(b2)); // 乘法 20.04
            System.out.println(b1.remainder(b2)); // 0.2
            System.out.println(b1.max(b2)); // 最大数 100.2
            System.out.println(b1.min(b2)); // 最小数 0.2
            System.out.println(b1.abs()); // 绝对值 0.2
            System.out.println(b1.negate()); // 相反数 -0.2
        }

**2、除法常用方法**

*   *  <table> 
         <tbody> 
          <tr> 
           <td><code><a rel="nofollow">BigDecimal</a></code></td> 
           <td><code><a rel="nofollow">divide</a>(<a rel="nofollow">BigDecimal</a>&nbsp;divisor, int&nbsp;scale, int&nbsp;roundingMode)</code> <p>返回一个 <code>BigDecimal</code> ，其值为 <code>(this / divisor)</code> ，其比例为指定。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">BigDecimal</a></code></td> 
           <td><code><a rel="nofollow">divide</a>(<a rel="nofollow">BigDecimal</a>&nbsp;divisor, int&nbsp;scale, <a rel="nofollow">RoundingMode</a>&nbsp;roundingMode)</code> <p>返回一个 <code>BigDecimal</code> ，其值为 <code>(this / divisor)</code> ，其比例为指定。</p> </td> 
          </tr> 
         </tbody> 
        </table>

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1][]

**舍入模式（BigDecimal 类 静态字段）：**

**常用的小学中的****四舍五入**：ROUND\_HALF\_UP

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2][]

**RoundingMode 其实是个枚举类，点进去源码可以看到其实他就是匹配到几种取舍规则**

public enum RoundingMode {
    
        UP(BigDecimal.ROUND_UP),
    
        DOWN(BigDecimal.ROUND_DOWN),
    
        CEILING(BigDecimal.ROUND_CEILING),
    
        FLOOR(BigDecimal.ROUND_FLOOR),
    
        HALF_UP(BigDecimal.ROUND_HALF_UP),
    
        HALF_DOWN(BigDecimal.ROUND_HALF_DOWN),
    
        HALF_EVEN(BigDecimal.ROUND_HALF_EVEN),
    
        UNNECESSARY(BigDecimal.ROUND_UNNECESSARY);
    
        ...
    }

**测试 demo**

public static void main(String[] args) {
            double d1 = 0.22;
            double d2 = 10.0;
            BigDecimal b1 = BigDecimal.valueOf(d1); // 0.22
            BigDecimal b2 = BigDecimal.valueOf(d2); // 10.0
            /**
             * 精确计算 10 除 0.22 == 45.45454545454545
             */
            /**
             *  ROUND_UP: 总是在非 0 舍弃小数(即截断)之前增加数字(向上取整)。
             *  ROUND_DOWN: 从不在舍弃(即截断)的小数之前增加数字(向下取整)。
             */
            System.out.println("ROUND_UP:" + b2.divide(b1, 3, BigDecimal.ROUND_UP));      // 45.455
            System.out.println("ROUND_DOWN:" + b2.divide(b1, 3, BigDecimal.ROUND_DOWN )); // 45.454
    
            /**
             *  ROUND_HALF_UP: 若舍弃部分>=.5，则作 ROUND_UP ；否则，作 ROUND_DOWN 。(小学中的四舍五入)
             *  ROUND_HALF_DOWN: 若舍弃部分> .5，则作 ROUND_UP；否则，作 ROUND_DOWN 。
             */
            System.out.println("ROUND_HALF_UP:" + b2.divide(b1, 3, BigDecimal.ROUND_HALF_UP));     // 45.455
            System.out.println("ROUND_HALF_DOWN::" + b2.divide(b1, 3, BigDecimal.ROUND_HALF_DOWN));// 45.455
    
            /**
             *  ROUND_CEILING: 如果 BigDecimal 是正的，则做 ROUND_UP 操作；如果为负，则做 ROUND_DOWN 操作。
             *  ROUND_FLOOR: 如果BigDecimal为正，则表现为ROUND_DOWN ; 如果为负，表现为ROUND_UP 。
             */
            System.out.println("ROUND_CEILING:" + b2.divide(b1, 3, BigDecimal.ROUND_CEILING)); // 45.455
            System.out.println("ROUND_FLOOR:" + b2.divide(b1, 3, BigDecimal.ROUND_FLOOR));     // 45.454
    
            /**
             *  ROUND_HALF_EVEN: 如果舍弃部分左边的数字为奇数，则作 ROUND_HALF_UP ；如果它为偶数，则作 ROUND_HALF_DOWN 。
             *  ROUND_UNNECESSARY: 该“伪舍入模式”实际是指明所要求的操作必须是精确的，因此不需要舍入。 
             *                     如果在产生不精确结果的操作上指定了舍入模式，则抛出ArithmeticException 。
             */
            System.out.println("ROUND_HALF_EVEN:" + b2.divide(b1, 3, BigDecimal.ROUND_HALF_EVEN));   // 45.455
            // System.out.println("ROUND_UNNECESSARY:" + b2.divide(b1, 3, BigDecimal.ROUND_UNNECESSARY)); // 
            /**
             *  RoundingMode 枚举类型一样
             */
            BigDecimal divide = b2.divide(b1, 3, RoundingMode.HALF_UP);
            System.out.println("RoundingMode.HALF_UP:" + divide);      // 加法 45.455
        }

### 三、BigInteger 类 ###

BigInteger 类是针对大 整数的处理类，而 BigDecimal 类则是针对大 小数的处理类。一般使用不多，用法同 BigDecimal 类似。这里就不测试啦。

BigInteger 类使用参考文章：[Java中BigInteger类的使用方法详解][Java_BigInteger]

ends ~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: /images/20211126/81a9ee7856ff43b5bf5071b9c6b805c8.png
[20190724153609912.png]: /images/20211126/ef366d1585d741c09359755f0d748a7e.png
[20190724154101901.png]: /images/20211126/e04b3bdae5764fdca3b5779e16ead8a8.png
[20190724153750730.png]: /images/20211126/cd21b97618884f6cb5eeea1868437b22.png
[2019072415514820.png]: /images/20211126/73b0aab1e2c54ef6a75047071ec66793.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1]: /images/20211126/58802bdfbf1d4dcebb1faf518b456339.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2]: /images/20211126/3ad96181e8c04f649a6412741f2a1f00.png
[Java_BigInteger]: https://blog.csdn.net/weixin_44259720/article/details/87002816