JAVA中如何对double或者float的浮点数进行精度计算

本篇介绍了在JAVA中如何对double或者float的浮点数进行精度计算，在JAVA中提供了多种参数来实现精度的不同控制方式。具体例子如下：

Java代码

1.   
2. package  com.soft4j.utility;   
3.   
4. import  java.math.BigDecimal;   
5.   
6.   
7. public   final   class  RoundTool {   
8.   
9.        
10.      public   static   double  round( double  value,  int  scale,  int  roundingMode) {   
11.         BigDecimal bd =  new  BigDecimal(value);   
12.         bd = bd.setScale(scale, roundingMode);   
13.          double  d = bd.doubleValue();   
14.         bd =  null ;   
15.          return  d;   
16.     }   
17.   
18.        
19.      public   static   void  main(String[] argc) {   
20.          //下面都以保留2位小数为例   
21.            
22.          //ROUND_UP   
23.          //只要第2位后面存在大于0的小数，则第2位就+1   
24.         System.out.println(round( 12.3401 , 2 ,BigDecimal.ROUND_UP)); //12.35   
25.         System.out.println(round(- 12.3401 , 2 ,BigDecimal.ROUND_UP)); //-12.35   
26.          //ROUND_DOWN   
27.          //与ROUND_UP相反   
28.          //直接舍弃第2位后面的所有小数   
29.         System.out.println(round( 12.349 , 2 ,BigDecimal.ROUND_DOWN)); //12.34   
30.         System.out.println(round(- 12.349 , 2 ,BigDecimal.ROUND_DOWN)); //-12.34   
31.          //ROUND_CEILING   
32.          //如果数字>0 则和ROUND_UP作用一样   
33.          //如果数字<0 则和ROUND_DOWN作用一样   
34.         System.out.println(round( 12.3401 , 2 ,BigDecimal.ROUND_CEILING)); //12.35   
35.         System.out.println(round(- 12.349 , 2 ,BigDecimal.ROUND_CEILING)); //-12.34   
36.          //ROUND_FLOOR   
37.          //如果数字>0 则和ROUND_DOWN作用一样   
38.          //如果数字<0 则和ROUND_UP作用一样   
39.         System.out.println(round( 12.349 , 2 ,BigDecimal.ROUND_FLOOR)); //12.34   
40.         System.out.println(round(- 12.3401 , 2 ,BigDecimal.ROUND_FLOOR)); //-12.35   
41.          //ROUND_HALF_UP [这种方法最常用]   
42.          //如果第3位数字>=5,则第2位数字+1     
43.          //备注:只看第3位数字的值,不会考虑第3位之后的小数的   
44.         System.out.println(round( 12.345 , 2 ,BigDecimal.ROUND_HALF_UP)); //12.35   
45.         System.out.println(round( 12.3449 , 2 ,BigDecimal.ROUND_HALF_UP)); //12.34   
46.         System.out.println(round(- 12.345 , 2 ,BigDecimal.ROUND_HALF_UP)); //-12.35   
47.         System.out.println(round(- 12.3449 , 2 ,BigDecimal.ROUND_HALF_UP)); //-12.34   
48.          //ROUND_HALF_DOWN   
49.          //如果第3位数字>=5,则做ROUND_UP   
50.          //如果第3位数字<5,则做ROUND_DOWN   
51.         System.out.println(round( 12.345 , 2 ,BigDecimal.ROUND_HALF_DOWN)); //12.35   
52.         System.out.println(round( 12.3449 , 2 ,BigDecimal.ROUND_HALF_DOWN)); //12.34   
53.         System.out.println(round(- 12.345 , 2 ,BigDecimal.ROUND_HALF_DOWN)); //-12.35   
54.         System.out.println(round(- 12.3449 , 2 ,BigDecimal.ROUND_HALF_DOWN)); //-12.34   
55.          //ROUND_HALF_EVEN   
56.          //如果第3位是偶数,则做ROUND_HALF_DOWN   
57.          //如果第3位是奇数,则做ROUND_HALF_UP   
58.         System.out.println(round( 12.346 , 2 ,BigDecimal.ROUND_HALF_EVEN)); //12.35   
59.         System.out.println(round( 12.345 , 2 ,BigDecimal.ROUND_HALF_EVEN)); //12.35   
60.     }   
61. }  

《Double精度的常用设置》

http://henry406.javaeye.com/blog/459669

 

import java.text.DecimalFormat;
import java.math.BigDecimal;

public class Test_Double{
   public static void main(String[] args){
       //-----方法1--------四舍五入  round对负数是五舍六入
       double d_1 = 123.9;
       System.out.println("d_1 = "+Math.round(d_1));
       //-------方法2------------------
       DecimalFormat decfmt = new DecimalFormat("##0.00");  
       System.out.println(decfmt.format(1.33482222));
       //--------方法3--------------
       double x = 1.33345;  
       java.text.NumberFormat formate = java.text.NumberFormat.getNumberInstance();  
       formate.setMaximumFractionDigits(3);//设定小数最大为数，那么显示的最后会四舍五入的  
       String m = formate.format(x);  
       System.out.println(m); 
       //--------方法4--------------
       BigDecimal bd = new BigDecimal(1.234543);  
       bd = bd.setScale(3,BigDecimal.ROUND_HALF_EVEN);  
       double d = bd.doubleValue();  
       System.out.println(d);
       //--------取消科学计数法-------------
       Double dValue = Double.valueOf("276363652844.8477474"); 
       System.out.println(dValue);
       BigDecimal original = new BigDecimal(dValue.doubleValue()); 
       BigDecimal result = original.setScale(2, BigDecimal.ROUND_HALF_DOWN);
       String test = result.toString();
       System.out.println(test);
   }
}

 

《 Java Double 精度问题总结 》

http://zhaow-381002134.javaeye.com/blog/420369

 

    使用Java，double 进行运算时，经常出现精度丢失的问题，总是在一个正确的结果左右偏0.0000**1。特别在实际项目中，通过一个公式校验该值是否大于0，如果大于0我们会做一件事情，小于0我们又处理其他事情。这样的情况通过double计算出来的结果去和0比较大小，尤其是有小数点的时候，经常会因为精度丢失而导致程序处理流程出错。
     所以一般对double类型进行运算时，做好对结果进行处理，然后拿这个值去做其他事情。

     目前总结如下：

      
    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;  
    }  


    
    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();
    }


   
    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();
    }

   
    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();
    }


   
    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);
}