java 小数精度问题

梦里梦外; 2022-05-23 02:52 201阅读 0赞

1、原因

由于浮点数在转化为二进制时无法运算完结，所以会无限循环下去，导致运算结果达不到期望值。

例如：1.14，转化为二进制，然后再转回十进制就变成了：1.1399999999999999023003738329862244427204132080078125。

2、场景

加减乘除运算就会出现失真，请看示例

package com.haobi.util;
    
    import java.math.BigDecimal;
    
    public class Test {
    
    	public static void main(String[] args) {
    		testdivide();
    		System.out.println("---------------");
    		testMultiply();
    	}
    	
    	
    	public static void testdivide(){
    		String aString = "1.14";
    		double b = Double.valueOf(aString);
    		System.out.println("double相除,精度丢失:"+b/10D);
    		System.out.println("double相除,精度丢失:"+new BigDecimal(Double.valueOf("1.14")).divide(new BigDecimal(10)));
    		System.out.println("string相除,精度正确:"+new BigDecimal("1.14").divide(new BigDecimal("10")));
    	}
    
    	public static void testMultiply(){
    		String aString = "1.14";
    		double b = Double.valueOf(aString);
    		BigDecimal bigDecimal = new BigDecimal(b);
    		int c = bigDecimal.multiply(new BigDecimal(100)).intValue();
    		System.out.println("b："+b);
    		System.out.println("BigDecimal，精度丢失："+bigDecimal);
    		System.out.println("double和int相乘，精度丢失："+b*100);
    		System.out.println("bigdouble和bigint相乘，精度丢失："+c);
    		System.out.println("bigString和bigint相乘，精度正确:"+new BigDecimal(aString).multiply(new BigDecimal(100)));
    		System.out.println("bigString和bigString相乘，精度正确:"+multiply(b,100).intValue()+"");
    	}
    	
    	/***
    	 * 两个数相乘
    	 * @param param1
    	 * @param param2
    	 * @return
    	 */
    	public static BigDecimal multiply(Object param1,Object param2){
    		if(param1==null||"".equals(param1.toString())){
    			param1 = "0";
    		}
    		if(param2==null||"".equals(param2.toString())){
    			param2 = "0";
    		}
    		try {
    			return new BigDecimal(param1.toString()).multiply(new BigDecimal(param2.toString()));
    		} catch (Exception e) {
    			return BigDecimal.ZERO;
    		}
    	}
    }

运行结果为：

double相除,精度丢失:0.11399999999999999  
double相除,精度丢失:0.11399999999999999023003738329862244427204132080078125  
string相除,精度正确:0.114  
\---------------  
b：1.14  
BigDecimal，精度丢失：1.1399999999999999023003738329862244427204132080078125  
double和int相乘，精度丢失：113.99999999999999  
bigdouble和bigint相乘，精度丢失：113  
bigString和bigint相乘，精度正确:114.00  
bigString和bigString相乘，精度正确:114

**参数类型为BigDecimal，但是先转换成了double，然后再转字符串**

public  static void main(String[] arg) {
    		BigDecimal a = new BigDecimal(889.2);
    		BigDecimal b = new BigDecimal(0.33);
    		System.out.println(new BigDecimal(a.toString()).add(new BigDecimal(b.toString())));//参数类型为BigDecimal直接转换成字符串了。
    		System.out.println(new BigDecimal(String.valueOf(a)).add(new BigDecimal(String.valueOf(b))));//参数类型为BigDecimal直接转换成字符串了。
    		System.out.println(new BigDecimal(String.valueOf(a.doubleValue())).add(new BigDecimal(String.valueOf(b.doubleValue()))));//参数类型为BigDecimal，但是先转换成了double，然后再转字符串
    		System.out.println(889.2+0.33);
    		
    	}

运行结果：

![20200921154810453.png][]

3、解决方法

使用jre提供的类BigDecimal，进行加减乘除运算，而且一定要使用字符串的构造方法，如：new BigDecimal("1.14")。不能使用数值类型，如：new BigDecimal(1.14)。而且不能直接把传入的参数使用BigDecimal类型。

4、工具类完整代码

/*** 修改于20200921
    	 * 两个数相加 
    	 * @param param1 
    	 * @param param2 必须为double,float等数字类型，不能为BigDecimal
    	 * @return
    	 */
    	public static BigDecimal add(Number param1,Number param2){
    		if(param1==null||"".equals(param1.toString())){
    			param1 = 0;
    		}
    		if(param2==null||"".equals(param2.toString())){
    			param2 = 0;
    		}
    		if(param1 instanceof BigDecimal) {//处理特殊类型
    			param1 = ((BigDecimal) param1).doubleValue();
    		}
    		if(param2 instanceof BigDecimal) {
    			param2 = ((BigDecimal) param2).doubleValue();
    		}
    		try {
    			return new BigDecimal(param1.toString()).add(new BigDecimal(param2.toString()));
    		} catch (Exception e) {
    			LOGGER.error("数字加法add异常,参数param1:"+param1.toString()+",参数param2:"+param2.toString(),e);
    			return BigDecimal.ZERO;
    		}
    	}
    	
    	/***
    	 * 两个数相减
    	 * @param param1
    	 * @param param2
    	 * @return
    	 */
    	public static BigDecimal subtract(Number param1,Number param2){
    		if(param1==null||"".equals(param1.toString())){
    			param1 = 0;
    		}
    		if(param2==null||"".equals(param2.toString())){
    			param2 = 0;
    		}
    		if(param1 instanceof BigDecimal) {//处理特殊类型
    			param1 = ((BigDecimal) param1).doubleValue();
    		}
    		if(param2 instanceof BigDecimal) {
    			param2 = ((BigDecimal) param2).doubleValue();
    		}
    		try {
    			return new BigDecimal(param1.toString()).subtract(new BigDecimal(param2.toString()));
    		} catch (Exception e) {
    			LOGGER.error("数字减法subtract异常,参数param1:"+param1.toString()+",参数param2:"+param2.toString(),e);
    			return BigDecimal.ZERO;
    		}
    	}
    	/***
    	 * 两个数相乘
    	 * @param param1
    	 * @param param2
    	 * @return
    	 */
    	public static BigDecimal multiply(Number param1,Number param2){
    		if(param1==null||"".equals(param1.toString())){
    			param1 = 0;
    		}
    		if(param2==null||"".equals(param2.toString())){
    			param2 = 0;
    		}
    		if(param1 instanceof BigDecimal) {//处理特殊类型
    			param1 = ((BigDecimal) param1).doubleValue();
    		}
    		if(param2 instanceof BigDecimal) {
    			param2 = ((BigDecimal) param2).doubleValue();
    		}
    		try {
    			return new BigDecimal(param1.toString()).multiply(new BigDecimal(param2.toString()));
    		} catch (Exception e) {
    			LOGGER.error("数字乘法multiply异常,参数param1:"+param1.toString()+",参数param2:"+param2.toString(),e);
    			return BigDecimal.ZERO;
    		}
    	}
    	/***
    	 * 两个数相除
    	 * @param param1 被除数
    	 * @param param2 除数
    	 * @param scale  小数保留位数
    	 * @return
    	 */
    	public static BigDecimal divide(Number param1,Number param2,int scale){
    		if(param1==null||"".equals(param1.toString())){
    			param1 = 0;
    		}
    		if(param2==null||"".equals(param2.toString())){
    			param2 = 0;
    		}
    		if(param1 instanceof BigDecimal) {//处理特殊类型
    			param1 = ((BigDecimal) param1).doubleValue();
    		}
    		if(param2 instanceof BigDecimal) {
    			param2 = ((BigDecimal) param2).doubleValue();
    		}
    		if(scale<0){
    			scale = 0;
    		}
    		try {
    			return new BigDecimal(param1.toString()).divide(new BigDecimal(param2.toString()),scale,RoundingMode.HALF_UP);
    		} catch (Exception e) {
    			LOGGER.error("数字除法divide异常,参数param1:"+param1.toString()+",参数param2:"+param2.toString(),e);
    			return BigDecimal.ZERO;
    		}
    	}
    	/***
    	 * 两个数相除,默认保留两位小数 
    	 * @param param1 被除数
    	 * @param param2 除数
    	 * @return
    	 */
    	public static BigDecimal divide(Number param1,Number param2){
    		if(param1==null||"".equals(param1.toString())){
    			param1 = 0;
    		}
    		if(param2==null||"".equals(param2.toString())){
    			param2 = 0;
    		}
    		return divide(param1,param2,2);//默认保留两位有效数字
    	}

[20200921154810453.png]: /images/20220523/76ab2482486a402f99570e4a53c84c2d.png