java 浮点计算 处理方案

 

32位微处理器开始支持浮点运算，java语言自己支持浮点运算。

浮点运算导致的问题有：四舍五入出错，四则运算出错，运算结果格式古怪等等。

问题的原因 其实简单：

1.计算机存储的数是近似数，同时为了显示不会太长根据需要会进行适当的舍操作

2.计算机存储的数是不连续的，这不同于实数，如果一个数不是计算机可完全表示的数则会找一个最接近的数来表示该数

3.四则运算，特别是除数被被除数相差很大等就会把上面存在的误差放大很多

4.各种编程语言的基本数据类型基本都有表示范围，所以存在溢出和越界的问题

错误示例：

123.3-》123.29999999999999；0.5/3-》0.16666666666666666；(1/2f)*840=168.00000250339508

java语言提供了对浮点数的支持，下面列举简单的几个点：

1.类型：java浮点格式的 基本数据类型有float，doulbe两

2.存储：java遵循ieee754标准。float(1+8+23)位，doulbe(1+11+52)位；第一个数字代表符号位，第二个数字代表指数，第三个数字代表分数。具体说明可参考http://blog.csdn.net/strollerV/archive/2007/05/22/1621382.aspx

3.精度： 浮点数值的精度是其有效数值中的有效数字个数的度量；double比float有更高的精度；表示1/3时，double的字面值0.3333333333333333比float的字面值0.3333333f有更高的精度

4.运算法则：双目运算中有一个浮点数是double型则运算时会先将float型转换成double再计算最终是double型数； java中分严格和非严格浮点运算，前者中间结果会适当舍入，在所以jvm上计算结果会一样，后者则通过低层硬件等实现中间过程的准确计算，应用于有特殊要求的地方。

针对java语言，使用现有java.math.BigDecimal作为桥梁可以解决，即数字要进行舍入或进行四则运算前先用BigDecimal封装再调用它的方法完成后再转换回原来的数据类型就行了。新问题是每次转换很麻烦，当然自己写个类封装四则运算以及定义四舍五入方式就好了 。下面是参考代码(网络资源),想法是一致的：

 

package  com.strongit.financesys.util;

import  java.math.BigDecimal;

/** */ /**
 * 
 * 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精
 * 
 * 确的浮点数运算，包括加减乘除和四舍五入。

 * 
 */

public   class  Arithmetic  ... {

    // 默认除法运算精度

    private static final int DEF_DIV_SCALE = 10;

    // 这个类不能实例化

    private Arithmetic() ...{

    }

    /** *//**
     * 
     * 提供精确的加法运算。

     * 
     * @param v1
     *            被加数

     * 
     * @param v2
     *            加数
     * 
     * @return 两个参数的和
     * 
     */

    public static double add(double v1, double v2) ...{

        BigDecimal b1 = new BigDecimal(Double.toString(v1));

        BigDecimal b2 = new BigDecimal(Double.toString(v2));

        return b1.add(b2).doubleValue();

    }

    /** *//**
     * 
     * 提供精确的减法运算。

     * 
     * @param v1
     *            被减数

     * 
     * @param v2
     *            减数
     * 
     * @return 两个参数的差
     * 
     */

    public static double sub(double v1, double v2) ...{

        BigDecimal b1 = new BigDecimal(Double.toString(v1));

        BigDecimal b2 = new BigDecimal(Double.toString(v2));

        return b1.subtract(b2).doubleValue();

    }

    /** *//**
     * 
     * 提供精确的乘法运算。

     * 
     * @param v1
     *            被乘数

     * 
     * @param v2
     *            乘数
     * 
     * @return 两个参数的积
     * 
     */

    public static double mul(double v1, double v2) ...{

        BigDecimal b1 = new BigDecimal(Double.toString(v1));

        BigDecimal b2 = new BigDecimal(Double.toString(v2));

        return b1.multiply(b2).doubleValue();

    }

    /** *//**
     * 
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 
     * 小数点以后10位，以后的数字四舍五入。

     * 
     * @param v1
     *            被除数

     * 
     * @param v2
     *            除数
     * 
     * @return 两个参数的商
     * 
     */

    public static double div(double v1, double v2) ...{

        return div(v1, v2, DEF_DIV_SCALE);

    }

    /** *//**
     * 
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指

     * 
     * 定精度，以后的数字四舍五入。

     * 
     * @param v1
     *            被除数

     * 
     * @param v2
     *            除数
     * 
     * @param scale
     *            表示表示需要精确到小数点以后几位。

     * 
     * @return 两个参数的商
     * 
     */

    public static double 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).doubleValue();

    }

    /** *//**
     * 
     * 提供精确的小数位四舍五入处理。

     * 
     * @param v
     *            需要四舍五入的数字
     * 
     * @param scale
     *            小数点后保留几位
     * 
     * @return 四舍五入后的结果
     * 
     */

    public static double 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).doubleValue();

    }

}

这个代码目前能稳定的处理java浮点数运算问题，我希望能共享大家对其改进后的成果。。。