JAVA中控制double和float的精度

http://stephen830./blog/260776

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

Java代码

/*
 * Created on 2005-6-5
 * Author stephen
 * Email zhoujianqiang AT gmail DOT com
 * CopyRight(C)2005-2008 , All rights reserved.
 */
package com.soft4j.utility;

import java.math.BigDecimal;

/**
 * 与小数位精度(四舍五入等)相关的一些常用工具方法.
 *
 * float/double的精度取值方式分为以下几种: <br>
 * java.math.BigDecimal.ROUND_UP <br>
 * java.math.BigDecimal.ROUND_DOWN <br>
 * java.math.BigDecimal.ROUND_CEILING <br>
 * java.math.BigDecimal.ROUND_FLOOR <br>
 * java.math.BigDecimal.ROUND_HALF_UP<br>
 * java.math.BigDecimal.ROUND_HALF_DOWN <br>
 * java.math.BigDecimal.ROUND_HALF_EVEN <br>
 *
 * @author stephen
 * @version 1.0.0
 */
public final class RoundTool {

    /**
     * 对double数据进行取精度.
     * <p>
     * For example: <br>
     * double value = 100.345678; <br>
     * double ret = round(value,4,BigDecimal.ROUND_HALF_UP); <br>
     * ret为100.3457 <br>
     *
     * @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;
    }

    /**
     * 测试用的main方法.
     *
     * @param argc
     *            运行参数.
     */
    public static void main(String[] argc) {
        //下面都以保留2位小数为例

        //ROUND_UP
        //只要第2位后面存在大于0的小数，则第2位就+1
        System.out.println(round(12.3401,2,BigDecimal.ROUND_UP));//12.35
        System.out.println(round(-12.3401,2,BigDecimal.ROUND_UP));//-12.35
        //ROUND_DOWN
        //与ROUND_UP相反
        //直接舍弃第2位后面的所有小数
        System.out.println(round(12.349,2,BigDecimal.ROUND_DOWN));//12.34
        System.out.println(round(-12.349,2,BigDecimal.ROUND_DOWN));//-12.34
        //ROUND_CEILING
        //如果数字>0 则和ROUND_UP作用一样
        //如果数字<0 则和ROUND_DOWN作用一样
        System.out.println(round(12.3401,2,BigDecimal.ROUND_CEILING));//12.35
        System.out.println(round(-12.349,2,BigDecimal.ROUND_CEILING));//-12.34
        //ROUND_FLOOR
        //如果数字>0 则和ROUND_DOWN作用一样
        //如果数字<0 则和ROUND_UP作用一样
        System.out.println(round(12.349,2,BigDecimal.ROUND_FLOOR));//12.34
        System.out.println(round(-12.3401,2,BigDecimal.ROUND_FLOOR));//-12.35
        //ROUND_HALF_UP [这种方法最常用]
        //如果第3位数字>=5,则第2位数字+1
        //备注:只看第3位数字的值,不会考虑第3位之后的小数的
        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_UP));//12.35
        System.out.println(round(12.3449,2,BigDecimal.ROUND_HALF_UP));//12.34
        System.out.println(round(-12.345,2,BigDecimal.ROUND_HALF_UP));//-12.35
        System.out.println(round(-12.3449,2,BigDecimal.ROUND_HALF_UP));//-12.34
        //ROUND_HALF_DOWN
        //如果第3位数字>=5,则做ROUND_UP
        //如果第3位数字<5,则做ROUND_DOWN
        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_DOWN));//12.35
        System.out.println(round(12.3449,2,BigDecimal.ROUND_HALF_DOWN));//12.34
        System.out.println(round(-12.345,2,BigDecimal.ROUND_HALF_DOWN));//-12.35
        System.out.println(round(-12.3449,2,BigDecimal.ROUND_HALF_DOWN));//-12.34
        //ROUND_HALF_EVEN
        //如果第3位是偶数,则做ROUND_HALF_DOWN
        //如果第3位是奇数,则做ROUND_HALF_UP
        System.out.println(round(12.346,2,BigDecimal.ROUND_HALF_EVEN));//12.35
        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_EVEN));//12.35
    }
}

---

相关文章：

 《Double精度的常用设置》

http://henry406./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./blog/420369

 

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


希望以上对大家有所帮助，如果说错了，还希望大家给点指正！

 

（#）