double a = 5.0;
double b = 0.1;
double c = 0.1;
System.out.println(a+b+c); //为什么结果是5.199999999999999,不应该是5.200000000000000吗?
使用Java,double 进行运算时,经常出现精度丢失的问题,总是在一个正确的结果左右偏0.0000**1。
特别在实际项目中,通过一个公式校验该值是否大于0,如果大于0我们会做一件事情,小于0我们又处理其他事情。
这样的情况通过double计算出来的结果去和0比较大小,尤其是有小数点的时候,经常会因为精度丢失而导致程序处理流程出错。
所以一般对double类型进行运算时,做好对结果进行处理,然后拿这个值去做其他事情。
目前总结如下:
/**
* 对double数据进行取精度.
* @param value double数据.
* @param scale 精度位数(保留的小数位数).
* @param roundingMode 精度取值方式.
* @return 精度计算后的数据.
*/
public static double round(double value, int scale,
int roundingMode) {
BigDecimal bd = new BigDecimal(value);
bd = bd.setScale(scale, roundingMode);
double d = bd.doubleValue();
bd = null;
return d;
}
/**
* double 相加
* @param d1
* @param d2
* @return
*/
public double sum(double d1,double d2){
BigDecimal bd1 = new BigDecimal(Double.toString(d1));
BigDecimal bd2 = new BigDecimal(Double.toString(d2));
return bd1.add(bd2).doubleValue();
}
/**
* double 相减
* @param d1
* @param d2
* @return
*/
public double sub(double d1,double d2){
BigDecimal bd1 = new BigDecimal(Double.toString(d1));
BigDecimal bd2 = new BigDecimal(Double.toString(d2));
return bd1.subtract(bd2).doubleValue();
}
/**
* double 乘法
* @param d1
* @param d2
* @return
*/
public double mul(double d1,double d2){
BigDecimal bd1 = new BigDecimal(Double.toString(d1));
BigDecimal bd2 = new BigDecimal(Double.toString(d2));
return bd1.multiply(bd2).doubleValue();
}
/**
* double 除法
* @param d1
* @param d2
* @param scale 四舍五入 小数点位数
* @return
*/
public double div(double d1,double d2,int scale){
// 当然在此之前,你要判断分母是否为0,
// 为0你可以根据实际需求做相应的处理
BigDecimal bd1 = new BigDecimal(Double.toString(d1));
BigDecimal bd2 = new BigDecimal(Double.toString(d2));
return bd1.divide
(bd2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
这样,计算double类型的数据计算问题就可以处理了。
另外补充一下 JavaScript 四舍五入的方法:
小数点问题
Math.round(totalAmount*100)/100 (保留 2 位)
function formatFloat(src, pos)
{
return Math.round(src*Math.pow(10, pos))/Math.pow(10, pos);
}
特别在实际项目中,通过一个公式校验该值是否大于0,如果大于0我们会做一件事情,小于0我们又处理其他事情。
这样的情况通过double计算出来的结果去和0比较大小,尤其是有小数点的时候,经常会因为精度丢失而导致程序处理流程出错。
所以一般对double类型进行运算时,做好对结果进行处理,然后拿这个值去做其他事情。
目前总结如下:
/**
* 对double数据进行取精度.
* @param value double数据.
* @param scale 精度位数(保留的小数位数).
* @param roundingMode 精度取值方式.
* @return 精度计算后的数据.
*/
public static double round(double value, int scale,
int roundingMode) {
BigDecimal bd = new BigDecimal(value);
bd = bd.setScale(scale, roundingMode);
double d = bd.doubleValue();
bd = null;
return d;
}
/**
* double 相加
* @param d1
* @param d2
* @return
*/
public double sum(double d1,double d2){
BigDecimal bd1 = new BigDecimal(Double.toString(d1));
BigDecimal bd2 = new BigDecimal(Double.toString(d2));
return bd1.add(bd2).doubleValue();
}
/**
* double 相减
* @param d1
* @param d2
* @return
*/
public double sub(double d1,double d2){
BigDecimal bd1 = new BigDecimal(Double.toString(d1));
BigDecimal bd2 = new BigDecimal(Double.toString(d2));
return bd1.subtract(bd2).doubleValue();
}
/**
* double 乘法
* @param d1
* @param d2
* @return
*/
public double mul(double d1,double d2){
BigDecimal bd1 = new BigDecimal(Double.toString(d1));
BigDecimal bd2 = new BigDecimal(Double.toString(d2));
return bd1.multiply(bd2).doubleValue();
}
/**
* double 除法
* @param d1
* @param d2
* @param scale 四舍五入 小数点位数
* @return
*/
public double div(double d1,double d2,int scale){
// 当然在此之前,你要判断分母是否为0,
// 为0你可以根据实际需求做相应的处理
BigDecimal bd1 = new BigDecimal(Double.toString(d1));
BigDecimal bd2 = new BigDecimal(Double.toString(d2));
return bd1.divide
(bd2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
这样,计算double类型的数据计算问题就可以处理了。
另外补充一下 JavaScript 四舍五入的方法:
小数点问题
Math.round(totalAmount*100)/100 (保留 2 位)
function formatFloat(src, pos)
{
return Math.round(src*Math.pow(10, pos))/Math.pow(10, pos);
}
温馨提示:答案为网友推荐,仅供参考
第1个回答 2014-12-18
浮点数值没办法用十进制来精确表示的原因要归咎于CPU表示浮点数的方法。这样的话您就可能会牺牲一些精度,有些浮点数运算也会引入误差。以上面提到的情况为例,2.4的二进制表示并非就是精确的2.4。反而最为接近的二进制表示是 2.3999999999999999。原因在于浮点数由两部分组成:指数和尾数。浮点数的值实际上是由一个特定的数学公式计算得到的。您所遇到的精度损失会在任何操作系统和编程环境中遇到。float类型的变量只有7位的精度,而double类型的变量有15位的精度
第2个回答 2014-12-18
使用Java,double 进行运算时,经常出现精度丢失的问题,总是在一个正确的结果左右偏0.0000**1。 特别在实际项目中,通过一个公式校验该值是否大于0,如果大于0我们会做一件事情,小于0我们又处理其他事情。 这样的情况通过double计算出来的结果去和0比较大小,尤其是有小数点的时候,经常会因为精度丢失而导致程序处理流程出错。
解决方法有:
//方法一
NumberFormat nFormat=NumberFormat.getNumberInstance();
nFormat.setMaximumFractionDigits(2);//设置小数点后面位数为
System.out.println(nFormat.format(3.1415););
/*
方法二
double d = 14.7155;
DecimalFormat df0 = new DecimalFormat("###");
DecimalFormat df1 = new DecimalFormat("###.0");
DecimalFormat df2 = new DecimalFormat("###.00");
System.out.println(df0.format(d));
System.out.println(df1.format(d));
System.out.println(df2.format(d));
double test = Math.round(d);
System.out.println(test);
*/
解决方法有:
//方法一
NumberFormat nFormat=NumberFormat.getNumberInstance();
nFormat.setMaximumFractionDigits(2);//设置小数点后面位数为
System.out.println(nFormat.format(3.1415););
/*
方法二
double d = 14.7155;
DecimalFormat df0 = new DecimalFormat("###");
DecimalFormat df1 = new DecimalFormat("###.0");
DecimalFormat df2 = new DecimalFormat("###.00");
System.out.println(df0.format(d));
System.out.println(df1.format(d));
System.out.println(df2.format(d));
double test = Math.round(d);
System.out.println(test);
*/
第3个回答 2014-12-18
这个就是double的精度问题啊?
java.math.BigDecimal
double n=0.01;
double m=0.06;
java.math.BigDecimal d1=new java.math.BigDecimal(String.valueOf(n));
java.math.BigDecimal d2=new java.math.BigDecimal(String.valueOf(m));
System.out.println(d1.add(d2).doubleValue());
java.math.BigDecimal
double n=0.01;
double m=0.06;
java.math.BigDecimal d1=new java.math.BigDecimal(String.valueOf(n));
java.math.BigDecimal d2=new java.math.BigDecimal(String.valueOf(m));
System.out.println(d1.add(d2).doubleValue());