【小家java】Java数值运算 [加减乘除] 精度丢失原因分析，提供保证精度的MathHelper工具类

我会带着你远行 2022-12-26 02:22 108阅读 0赞

每篇一句

> 人可以被打败，但不会被击垮

啥都不说，先看一个例子

public static void main(String[] args) {
            //加减乘除都出现了对应的精度问题
            System.out.println(0.05 + 0.01); //0.060000000000000005
            System.out.println(1.0 - 0.42); //0.5800000000000001
            System.out.println(4.015 * 100); //401.49999999999994
            System.out.println(123.3 / 100); //1.2329999999999999
        }

有没有一种触目惊心的感觉，感觉回去检查检查自己的代码，有没有一些数值运算吧，哈哈。这个问题相当严重，比如你有9.999999999999元，你的计算机是不会认为你可以购买10元的商品的。在有的编程语言中提供了专门的货币类型来处理这种情况，但是Java没有。

下面会解释原因以及提出解决方案。但结论可以先给大家：

> `Java中的简单浮点数类型float和double不能够进行运算。`

问题分析

我们的第一个反应是做四舍五入。Math类中的round方法不能设置保留几位小数，我们只能象这样（保留两位）：

public double round(double value){
        return Math.round(value*100)/100.0;
    }

非常不幸，上面的代码并不能正常工作，给这个方法传入4.015它将返回4.01而不是4.02，如我们在上面看到的`4.015*100=401.49999999999994`

因此如果我们要做到精确的四舍五入，**不能利用简单类型做任何运算**  
java.text.DecimalFormat也不能解决这个问题：

System.out.println(new java.text.DecimalFormat("0.00").format(4.025)); //4.02

> 现在我们已经可以解决这个问题了，原则是使用BigDecimal并且`一定要用String来构造。否则见下面例子`

public static void main(String[] args) {
            double g = 12.35;
            BigDecimal bigG = new BigDecimal(g).setScale(1, BigDecimal.ROUND_HALF_UP);
            System.out.println(bigG.doubleValue()); //期望得到12.4  但实际输出：12.3
        }

大概原因：定义double g= 12.35; 而在计算机中二进制表示可能这是样：定义了一个g=12.34444444444444449，  
new BigDecimal(g) g还是12.34444444444444449  
new BigDecimal(g).setScale(1, BigDecimal.ROUND\_HALF\_UP); 得到12.3

正确的定义方式是使用字符串构造函数：

new BigDecimal("12.35").setScale(1, BigDecimal.ROUND_HALF_UP)

解决方案

上面也已经提到过了，我们可以借助BigDecimal来解决这个问题。因此此处我提供一共工具类，\*\*以后大家java中的数值运算都采用此工具类处理，就绝对不会有精度问题了：MathHelper \*\*

import java.math.BigDecimal;
    
    /**
     * 精确的加减乘除的工具类
     *
     * @author fangshixiang
     * @description //
     * @date 2019/1/16 16:34
     */
    public abstract class MathHelper {
    
        //默认10才能进位
        private static final int DEF_DIV_SCALE = 10;
    
        /**
         * 提供精确的加法运算。
         *
         * @param v1 被加数
         * @param v2 加数
         * @return 两个参数的和 double
         */
        public static BigDecimal add(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.add(b2);
        }
    
        /**
         * 提供精确的减法运算。
         *
         * @param v1 被减数
         * @param v2 减数
         * @return 两个参数的差 double
         */
        public static BigDecimal sub(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.subtract(b2);
        }
    
        /**
         * 提供精确的乘法运算。
         *
         * @param v1 被乘数
         * @param v2 乘数
         * @return 两个参数的积 double
         */
        public static BigDecimal mul(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.multiply(b2);
        }
    
        /**
         * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到 小数点以后10位,以后的数字四舍五入。
         *
         * @param v1 被除数
         * @param v2 除数
         * @return 两个参数的商 double
         */
        public static BigDecimal div(double v1, double v2) {
            return div(v1, v2, DEF_DIV_SCALE);
        }
    
        /**
         * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指 定精度,以后的数字四舍五入。
         *
         * @param v1    被除数
         * @param v2    除数
         * @param scale 表示表示需要精确到小数点以后几位。
         * @return 两个参数的商 double
         */
        public static BigDecimal div(double v1, double v2, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException(
                        "The scale must be a positive integer or zero");
            }
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP);
        }
    
        /**
         * 提供精确的小数位四舍五入处理。
         *
         * @param v     需要四舍五入的数字
         * @param scale 小数点后保留几位
         * @return 四舍五入后的结果 double
         */
        public static BigDecimal round(double v, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException("The scale must be a positive integer or zero");
            }
            BigDecimal b = new BigDecimal(Double.toString(v));
            BigDecimal one = new BigDecimal("1");
            return b.divide(one, scale, BigDecimal.ROUND_HALF_UP);
        }
    }

提供加减乘除、四舍五入的方法。保证精度。返回值类型为保证精度的BigDecimal类型，根据业务需要请转换为自己需要的类型。

**下面我们利用此工具类把上面例子再跑一次：**

public static void main(String[] args) {
            System.out.println(add(0.05, 0.01)); //0.06
            System.out.println(sub(1.0, 0.42)); //0.58
            System.out.println(mul(4.015, 100)); //401.5000
            System.out.println(div(123.3, 100)); //1.2330000000
    
            //返回值用double展示  可以保证精度
            System.out.println(add(0.05, 0.01).doubleValue()); //0.06
            System.out.println(sub(1.0, 0.42).doubleValue()); //0.58
            System.out.println(mul(4.015, 100).doubleValue()); //401.5
            System.out.println(div(123.3, 100).doubleValue()); //1.233
        }

public static void main(String[] args) {
            Integer i = 1;
            Long l = 1L;
            Float f = 1.0f;
    
            //这样转换成double类型 或者直接强转
            System.out.println(i.doubleValue()); //1.0
            System.out.println(l.doubleValue()); //1.0
            System.out.println(f.doubleValue()); //1.0
        }

如上，若返回值不知道是整数还是小数，请使用double接收。因为double强转为int是会失去精度的

public static void main(String[] args) {
            System.out.println(add(0.05, 0.01).intValue()); //0
            System.out.println(sub(1.0, 0.42).intValue()); //0
            System.out.println(mul(4.015, 100).intValue()); //401
            System.out.println(div(123.3, 100).intValue()); //1
    
            //double强转为int、long问题   它会直接舍弃小数部分保留整数部分  需要注意
            System.out.println((int) 3.41); //3
            System.out.println((int) 3.81); //3
        }

失掉精度的根本原因解释

计算机进行的是二进制运算，我们输入的十进制数字会先转换成二进制，进行运算后再转换为十进制输出。Float和Double提供了快速的运算，然而问题在于转换为二进制的时候，**有些数字不能完全转换，只能无限接近于原本的值**，这就导致了在后来的运算会出现不正确结果的情况。

浮点数由两部分组成：指数和尾数，这点如果知道怎样进行`浮点数的二进制与十进制转换`，应该是不难理解的。

如果在这个转换的过程中，**浮点数参与了计算**，那么转换的过程就会变得不可预 知，并且变得不可逆。

我们有理由相信，就是在这个过程中，发生了精度的丢失。而至于为什么有些浮点计算会得到准确的结果，应该也是碰巧那个计算的二进制与 十进制之间能够准确转换。而当输出单个浮点型数据的时候，可以正确输出

double d = 2.4;
    System.out.println(d); //2.4而不是2.3999999999999999

> 也就是说，不进行浮点计算的时候，在十进制里浮点数能正确显示。事实上，浮点数并不适合用于精确计算，而适合进行科学计算。

十进制小数的二进制表示：

`整数部分：`除以2，取出余数，商继续除以2，直到得到0为止，将取出的余数逆序  
`小数部分：`乘以2，然后取出整数部分，将剩下的小数部分继续乘以2，然后再取整数部分，一直取到小数部分为零为止。**如果永远不为零，则按要求保留足够位数的小数，最后一位做0舍1入。将取出的整数顺序排列。（因此肯定就可能失精度了）**

小知识点

既然float和double型用来表示带有小数点的数，那为什么我们不称 它们为“小数”或者“实数”，要叫浮点数呢？因为这些数都以科学计数法的形式存储。当一个数如50.534，转换成科学计数法的形式为5.053e1，它 的小数点移动到了一个新的位置（即浮动了）。**可见，浮点数本来就是用于科学计算的，用来进行精确计算实在太不合适了。**

举个栗子

> 整数除以2肯定会有个尽头的，之后二进制还原成十进制只需要乘以2即可。`所以只有浮点数才可能存在精度问题`

public static void main(String[] args) {
            System.out.println(2.0 -1.1); //0.8999999999999999
        }

8个字节，有效位15位。其中52小数，11位偏指数，1位符号。其中1.1是没有办法用二进制精确表示的。  
1.1的二进制大约就是这样1.0001100110011001。小数部分一直是1001所以，只能取一个52精度的数近似代替1.1.因此，最终结果肯定会有误差。

同理，任意一个整数都是可以使用二进制精确表示，所以只要不超过精度总可以精确表示，但是小数往往不能使用二进制**精确表示**。

JDK提供的Math类

Math类为Java类库提供给我们的处理一些数学运算的。由于很多读者其实不是很熟，因此本人整理如下一个Demo出来，仅供参考哈

public static void main(String[] args) {
           int divive = 2;
    
           double i = 1 / divive;
           int ii = 1 / divive;
           double iii = 1.0 / divive;
           System.out.println(i); //0.0
           System.out.println(ii); //0
           System.out.println(iii); //0.5
    
           System.out.println(Math.ceil(1.01)); //2.0
           System.out.println(Math.ceil(0.5)); //1.0
    
           //三角函数方法
           System.out.println("90 度的正弦值：" + Math.sin(Math.PI / 2)); //90 度的正弦值：1.0
           System.out.println("0 度的余弦值：" + Math.cos(0)); //0 度的余弦值：1.0
           System.out.println("60 度的正切值：" + Math.tan(Math.PI / 3)); //60 度的正切值：1.7320508075688767
           System.out.println("2 的平方根与 2 商的反正弦值：" + Math.asin(Math.sqrt(2) / 2)); //2 的平方根与 2 商的反正弦值：0.7853981633974484
           System.out.println("2 的平方根与 2 商的反余弦值：" + Math.acos(Math.sqrt(2) / 2)); //2 的平方根与 2 商的反余弦值：0.7853981633974483
           System.out.println("1 的反正切值：" + Math.atan(1)); //1 的反正切值：0.7853981633974483
           System.out.println("120 度的弧度值：" + Math.toRadians(120.0)); //120 度的弧度值：2.0943951023931953
           System.out.println("π/2 的角度值：" + Math.toDegrees(Math.PI / 2)); //π/2 的角度值：90.0
    
           //指数函数方法
           System.out.println("e 的平方值：" + Math.exp(2)); //e 的平方值：7.38905609893065
           System.out.println("以 e 为底 2  的对数值：" + Math.log(2)); //以 e 为底 2  的对数值：0.6931471805599453
           System.out.println("以 10 为底 2  的对数值：" + Math.log10(2)); //以 10 为底 2  的对数值：0.3010299956639812
           System.out.println("4 的平方根值：" + Math.sqrt(2)); //4 的平方根值：1.4142135623730951
           System.out.println("8 的立平方根值：" + Math.cbrt(2)); //8 的立平方根值：1.2599210498948732
           System.out.println("2 的 2 次方值：" + Math.pow(2, 2)); //2 的 2 次方值：4.0
    
           //取整函数方法
           System.out.println("使用 ceil() 方法取整：" + Math.ceil(5.2)); //向上取整：6.0
           System.out.println("使用 floor() 方法取整：" + Math.floor(2.5)); //向下取整：2.0
    
           //rint（）：返回最接近参数的整数，如果有2个数同样接近，则返回偶数的那个。
           //round（）就是数学上的四舍五入。
           System.out.println("使用 rint() 方法取整：" + Math.rint(2.7)); // 四舍五入：3.0（此方法非常特殊）
           System.out.println("使用 int round() 方法取整：" + Math.round(3.4f)); //四舍五入：3
           System.out.println("使用 long round() 方法取整：" + Math.round(2.5)); //四舍五入：3
    
           //最大、最小值
           System.out.println("4 和 8 较大者：" + Math.max(4, 8)); //8
           System.out.println("4.4 和 4 较小者：" + Math.min(4.4, 4)); //4.0
           System.out.println("-7 的绝对值：" + Math.abs(-7)); //7
    
       }

转载地址：[https://blog.csdn.net/f641385712/article/details/86525051][https_blog.csdn.net_f641385712_article_details_86525051]

[https_blog.csdn.net_f641385712_article_details_86525051]: https://blog.csdn.net/f641385712/article/details/86525051