posts - 40,  comments - 187,  trackbacks - 0

说在前面的话

        先祝各位看官在虎年里虎虎生威,财源广进,万事如意!


        Java 语言支持两种基本的浮点类型: floatdouble ,以及与它们对应的包装类 FloatDouble 。它们都依据 IEEE 754 标准,该标准为 32 位浮点和 64 位双精度浮点二进制小数定义了二进制标准。
        但是在一些项目中,一些非整数值(如几元和几分这样的小数)需要很精确。所以,不要用浮点数表示精确值。浮点数不是精确值,所以使用它们会导致舍入误差。因此,使用浮点数来试图表示象货币量这样的精确数量不是一个好的想法。使用浮点数来进行元和分计算会得到灾难性的后果。浮点数最好用来表示象测量值这类数值,这类值从一开始就不怎么精确。
        所以一般对double类型进行运算时,做好对结果进行处理,然后拿这个值去做其他事情。 下面我们就用代码来说明一下如何对浮点数进行精度计算,以double为例。


详细代码(注释很详细 不做解释了)  可点击这里下载代码

/*
 * Copyright reserved 2010 by AllensLab
 * @project AllensLab
 * @date Feb 22, 2010
 
*/

package cn.allen.tools;

import
 java.math.BigDecimal;

/**
 * RoundTool
 * 
@author allen
 * @time 10:05:40 AM Feb 22, 2010
 
*/

public class RoundTools {
    
/**  
     * 对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;
    }

    
    
public static BigDecimal roundAgain(double value, int scale, int roundingMode) {
        BigDecimal bd 
= new
 BigDecimal(value);
        bd 
=
 bd.setScale(scale, roundingMode);
        
return
 bd;
    }

    
    
/* 用于加、减、乘和除的方法给 BigDecimal 值提供了算术运算。由于 BigDecimal 对象是不可变的,这些方法中的每一个都会产生新的 BigDecimal 对象。
     * 因为创建对象的开销, BigDecimal 不适合于大量的数学计算,但设计它的目的是用来精确地表示小数。 
*/

    
    
/**
     * Addition
     * 
@param number1
     * 
@param
 number2
     * 
@return

     * 
@author allen
     * @date 10:42:47 AM Feb 22, 2010
     
*/

    
public static double add(double number1, double number2, int newScale, int roundingMode) {
        
return
 BigDecimal.valueOf(number1).add(BigDecimal.valueOf(number2)).setScale(newScale, roundingMode).doubleValue();
    }

    
    
public static double add(int newScale, int roundingMode, double number1, double numbers) {
        BigDecimal bd 
= new
 BigDecimal(number1);
        
for (double number : numbers) 
{
            bd 
=
 bd.add(BigDecimal.valueOf(number).setScale(newScale, roundingMode));
        }

        
return bd.doubleValue();
    }

    
    
/**
     * Subtraction
     * 
@param number1
     * 
@param
 number2
     * 
@return

     * 
@author allen
     * @date 10:45:36 AM Feb 22, 2010
     
*/

    
public static double subtract(double number1, double number2, int newScale, int roundingMode) {
        
return
 BigDecimal.valueOf(number1).subtract(BigDecimal.valueOf(number2)).setScale(newScale, roundingMode).doubleValue();
    }

    
    
/**
     * Multiplication 
     * 
@param number1
     * 
@param
 number2
     * 
@return

     * 
@author allen
     * @date 10:46:23 AM Feb 22, 2010
     
*/

    
public static double multiply(double number1, double number2, int newScale, int roundingMode) {
        
return
 BigDecimal.valueOf(number1).multiply(BigDecimal.valueOf(number2)).setScale(newScale, roundingMode).doubleValue();
        
    }

    
    
/**
     * Division
     * 尽量采用财务常用的四舍六入五取偶 即ROUND_HALF_EVEN
     * 
@param number1
     * 
@param
 number2
     * 
@return

     * 
@author allen
     * @date 10:47:12 AM Feb 22, 2010
     
*/

    
public static double divide(double number1, double number2, int scale, int roundingMode) {
        
return
 BigDecimal.valueOf(number1).divide(BigDecimal.valueOf(number2), scale, roundingMode).doubleValue();
    }

    
    
/**  
     * 测试用的main方法.  
     *   
     * 
@param
 args  
     *            运行参数.  
     
*/

    
public static void main(String[] args) {
        
//下面都以保留2位小数为例   

        System.out.println(add(12.34112.34492, BigDecimal.ROUND_HALF_EVEN));
        System.out.println(add(
2, BigDecimal.ROUND_HALF_UP, 12.34612.344912.340112.345
));
        System.out.println(subtract(
12.344912.3412
, BigDecimal.ROUND_HALF_EVEN));
        System.out.println(multiply(
12.34490.012
, BigDecimal.ROUND_HALF_UP));
        System.out.println(divide(
11.34112.3462
, BigDecimal.ROUND_HALF_EVEN));
        
//
ROUND_UP   
        
//只要第2位后面存在大于0的小数,则第2位就+1

        System.out.println("-- ROUND_UP -- 只要第2位后面存在大于0的小数,则第2位就+1 --");
        System.out.println(round(
12.34012, BigDecimal.ROUND_UP));//12.35   

        System.out.println(round(-12.34012, BigDecimal.ROUND_UP));//-12.35   
        
//
ROUND_DOWN   
        
//
与ROUND_UP相反   
        
//直接舍弃第2位后面的所有小数   

        System.out.println("-- ROUND_DOWN -- 直接舍弃第2位后面的所有小数 --");
        System.out.println(round(
12.3492, BigDecimal.ROUND_DOWN));//12.34   

        System.out.println(round(-12.3492, BigDecimal.ROUND_DOWN));//-12.34   
        
//
ROUND_CEILING   
        
//
如果数字>0 则和ROUND_UP作用一样   
        
//如果数字<0 则和ROUND_DOWN作用一样   

        System.out.println("-- OUND_CEILING -- 如果数字>0 则和ROUND_UP作用一样 如果数字<0 则和ROUND_DOWN作用一样 --");
        System.out.println(round(
12.34012, BigDecimal.ROUND_CEILING));//12.35   

        System.out.println(round(-12.3492, BigDecimal.ROUND_CEILING));//-12.34   
        
//
ROUND_FLOOR   
        
//
如果数字>0 则和ROUND_DOWN作用一样   
        
//如果数字<0 则和ROUND_UP作用一样   

        System.out.println("-- ROUND_FLOOR -- 如果数字>0 则和ROUND_DOWN作用一样 如果数字<0 则和ROUND_UP作用一样 --");
        System.out.println(round(
12.3492, BigDecimal.ROUND_FLOOR));//12.34   

        System.out.println(round(-12.34012, BigDecimal.ROUND_FLOOR));//-12.35   
        
//
ROUND_HALF_UP [这种方法最常用]   
        
//
如果第3位数字>=5,则第2位数字+1   
        
//备注:只看第3位数字的值,不会考虑第3位之后的小数的   

        System.out.println("-- ROUND_HALF_UP -- 如果第3位数字>=5,则第2位数字+1 --");
        System.out.println(round(
12.3452, BigDecimal.ROUND_HALF_UP));//12.35   

        System.out.println(round(12.34492, BigDecimal.ROUND_HALF_UP));//12.34   
        System.out.println(round(-12.3452, BigDecimal.ROUND_HALF_UP));//-12.35   
        System.out.println(round(-12.34492, BigDecimal.ROUND_HALF_UP));//-12.34   
        
//
ROUND_HALF_DOWN   
        
//
如果第3位数字>=5,则做ROUND_UP   
        
//如果第3位数字<5,则做ROUND_DOWN   

        System.out.println("-- ROUND_HALF_DOWN -- 如果第3位数字>=5,则做ROUND_UP,如果第3位数字<5,则做ROUND_DOWN --");
        System.out.println(round(
12.3452, BigDecimal.ROUND_HALF_DOWN));//12.35   

        System.out.println(round(12.34492, BigDecimal.ROUND_HALF_DOWN));//12.34   
        System.out.println(round(-12.3452, BigDecimal.ROUND_HALF_DOWN));//-12.35   
        System.out.println(round(-12.34492, BigDecimal.ROUND_HALF_DOWN));//-12.34   
        
//
ROUND_HALF_EVEN   
        
//
如果第3位是偶数,则做ROUND_HALF_DOWN   
        
//如果第3位是奇数,则做ROUND_HALF_UP   

        System.out.println("-- ROUND_HALF_EVEN -- 如果第3位是偶数,则做ROUND_HALF_DOWN,如果第3位是奇数, 则做ROUND_HALF_UP --");
        System.out.println(round(
12.3462, BigDecimal.ROUND_HALF_EVEN));//12.35   

        System.out.println(round(12.3452, BigDecimal.ROUND_HALF_EVEN));//12.35   
    }

}


再说说BigDecimal

用于较小数的 BigDecimal

从 JDK 1.3 起,Java 开发人员就有了另一种数值表示法来表示非整数: BigDecimalBigDecimal 是标准的类,在编译器中不需要特殊支持,它可以表示任意精度的小数,并对它们进行计算。在内部,可以用任意精度任何范围的值和一个换算因子来表示 BigDecimal ,换算因子表示左移小数点多少位,从而得到所期望范围内的值。因此,用 BigDecimal 表示的数的形式为 unscaledValue*10 -scale

用于加、减、乘和除的方法给 BigDecimal 值提供了算术运算。由于 BigDecimal 对象是不可变的,这些方法中的每一个都会产生新的 BigDecimal 对象。因此,因为创建对象的开销, BigDecimal 不适合于大量的数学计算,但设计它的目的是用来精确地表示小数。如果您正在寻找一种能精确表示如货币量这样的数值,则 BigDecimal 可以很好地胜任该任务。

所有的 equals 方法都不能真正测试相等

如浮点类型一样, BigDecimal 也有一些令人奇怪的行为。尤其在使用 equals() 方法来检测数值之间是否相等时要小心。 equals() 方法认为,两个表示同一个数但换算值不同(例如, 100.00100.000 )的 BigDecimal 值是不相等的。然而, compareTo() 方法会认为这两个数是相等的,所以在从数值上比较两个 BigDecimal 值时,应该使用 compareTo() 而不是 equals()

另外还有一些情形,任意精度的小数运算仍不能表示精确结果。例如, 1 除以 9 会产生无限循环的小数 .111111... 。出于这个原因,在进行除法运算时, BigDecimal 可以让您显式地控制舍入。 movePointLeft() 方法支持 10 的幂次方的精确除法。

使用 BigDecimal 作为互换类型

SQL-92 包括 DECIMAL 数据类型,它是用于表示定点小数的精确数字类型,它可以对小数进行基本的算术运算。一些 SQL 语言喜欢称此类型为 NUMERIC 类型,其它一些 SQL 语言则引入了 MONEY 数据类型,MONEY 数据类型被定义为小数点右侧带有两位的小数。

如果希望将数字存储到数据库中的 DECIMAL 字段,或从 DECIMAL 字段检索值,则如何确保精确地转换该数字?您可能不希望使用由 JDBC PreparedStatementResultSet 类所提供的 setFloat()getFloat() 方法,因为浮点数与小数之间的转换可能会丧失精确性。相反,请使用 PreparedStatementResultSetsetBigDecimal()getBigDecimal() 方法。

对于 BigDecimal ,有几个可用的构造函数。其中一个构造函数以双精度浮点数作为输入,另一个以整数和换算因子作为输入,还有一个以小数的 String 表示作为输入。要小心使用 BigDecimal(double) 构造函数,因为如果不了解它,会在计算过程中产生舍入误差。请使用基于整数或 String 的构造函数。

构造 BigDecimal 数

对于 BigDecimal ,有几个可用的构造函数。其中一个构造函数以双精度浮点数作为输入,另一个以整数和换算因子作为输入,还有一个以小数的 String 表示作为输入。要小心使用 BigDecimal(double) 构造函数,因为如果不了解它,会在计算过程中产生舍入误差。请使用基于整数或 String 的构造函数。

如果使用 BigDecimal(double) 构造函数不恰当,在传递给 JDBC setBigDecimal() 方法时,会造成似乎很奇怪的 JDBC 驱动程序中的异常。例如,考虑以下 JDBC 代码,该代码希望将数字 0.01 存储到小数字段:

 PreparedStatement ps =
            connection.prepareStatement("INSERT INTO Foo SET name=?, value=?");
            ps.setString(1, "penny");
            ps.setBigDecimal(2, new BigDecimal(0.01));
            ps.executeUpdate();
            

在执行这段似乎无害的代码时会抛出一些令人迷惑不解的异常(这取决于具体的 JDBC 驱动程序),因为 0.01 的双精度近似值会导致大的换算值,这可能会使 JDBC 驱动程序或数据库感到迷惑。JDBC 驱动程序会产生异常,但可能不会说明代码实际上错在哪里,除非意识到二进制浮点数的局限性。相反,使用 BigDecimal("0.01")BigDecimal(1, 2) 构造 BigDecimal 来避免这类问题,因为这两种方法都可以精确地表示小数。


本文参考了一下文章,对这些作者表示感谢!

Java 理论与实践: 您的小数点到哪里去了?

Java Double 精度问题总结

JAVA对double或者float的浮点数精度计算控制方法

 

                                                                 THE END

posted on 2010-02-22 13:59 小立飞刀 阅读(5499) 评论(0)  编辑  收藏 所属分类: Others

只有注册用户登录后才能发表评论。


网站导航:
 
<2010年2月>
31123456
78910111213
14151617181920
21222324252627
28123456
78910111213

生存或毁灭,这是个必答之问题:是否应默默的忍受坎苛命运之无情打击,还是应与深如大海之无涯苦难奋然为敌,并将其克服。此二抉择,究竟是哪个较崇高?

常用链接

留言簿(12)

随笔分类(43)

相册

收藏夹(7)

朋友的博客

电子资料

搜索

  •  

积分与排名

  • 积分 - 301832
  • 排名 - 192

最新评论

阅读排行榜

评论排行榜