BigDecimal⾼精度计算熟悉扩展,java除法保留⼩数问题
java保留两位⼩数问题:
⽅式⼀:
四舍五⼊
double f = 111231.5585;
BigDecimal b = new BigDecimal(f);
double f1 = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
保留两位⼩数
---------------------------------------------------------------
⽅式⼆:
df.format(你要格式化的数字);
例:DecimalFormat("#.00").format(3.1415926)
#.00 表⽰两位⼩数 #.0000四位⼩数以此类推...
⽅式三:
double d = 3.1415926;
String result = String .format("%.2f");
%.2f %. 表⽰⼩数点前任意位数 2 表⽰两位⼩数格式后的结果为f 表⽰浮点型
⽅式四:
NumberFormat NumberInstance() ;
void setMaximumFractionDigits(int digits)
digits 显⽰的数字位数
为格式化对象设定⼩数点后的显⽰的最多位,显⽰的最后位是舍⼊的
* ;
import java.math.* ;
class TT
{
public static void main(String args[])
{ double x=23.5455;
NumberFormat NumberInstance() ;
ddf1.setMaximumFractionDigits(2);
String s= ddf1.format(x) ;
System.out.print(s);
}
}
---------------------------------------------------------------------------------------------------------
有⼀篇:
(1)、浮点数精确计算
胜利油⽥三流合⼀项⽬中⼀直存在⼀个问题,就是每次报表统计的物资⾦额和实际的⾦额要差那么⼏分钱,和实际⾦额不⼀致,让客户觉得总是不那么舒服,原因是因为我们使⽤java的浮点类型double来定义物资⾦额,并且在报表统计中我们经常要进⾏⼀些运算,但Java中浮点数(double、float)的计算是⾮精确计算,请看下⾯⼀个例⼦:
System.out.println(0.05 + 0.01);
System.out.println(1.0 - 0.42);
System.out.println(4.015 * 100);
System.out.println(123.3 / 100);
你的期望输出是什么?可实际的输出确实这样的:
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
这个问题就⾮常严重了,如果你有123.3元要购买商品,⽽计算机却认为你只有123.29999999999999元,钱不够,计算机拒绝交易。
(2)、四舍五⼊
是否可以四舍五⼊呢?当然可以,习惯上我们本能就会这样考虑,但四舍五⼊意味着误差,商业运算中可能意味着错误,同时Java中也没有提供保留指定位数的四舍五⼊⽅法,只提供了⼀个und(double d)和und(float f)的⽅法,分别返回长整型和整型值。round⽅法不能设置保留⼏位⼩数,我们只能象这样(保留两位):
public double round(double value){
und( value * 100 ) / 100.0;
}
但⾮常不幸的是,上⾯的代码并不能正常⼯作,给这个⽅法传⼊4.015它将返回4.01⽽不是4.02,如我们在上⾯看到的
4.015 * 100 = 401.49999999999994
因此如果我们要做到精确的四舍五⼊,这种⽅法不能满⾜我们的要求。
还有⼀种⽅式是使⽤DecimalFormat,但也存在问题,format采⽤的舍⼊模式是ROUND_HALF_DOWN(舍⼊模式在下⾯有介绍),⽐如说4.025保留两位⼩数会是4.02,因为.025距离” nearest neighbor”(.02和.03)长度是相等,向下舍⼊就是.02,如果是4.0251那么保留两位⼩数就是4.03。
System.out.println(DecimalFormat("0.00").format(4.025));
System.out.println(DecimalFormat("0.00").format(4.0251));
输出是
4.02
4.03
(3)、浮点数输出(科学记数法)
Java浮点型数值在⼤于9999999.0就⾃动转化为科学记数法来表⽰,我们看下⾯的例⼦:
System.out.println(999999999.04);
System.out.println(99999999.04);
System.out.println(10000000.01);
System.out.println(9999999.04);
输出的结果如下:
9.9999999904E8
9.999999904E7
1.000000001E7
9999999.04
但有时我们可能不需要科学记数法的表⽰⽅法,需要转换为字符串,还不能直接⽤toString()等⽅法转换,很烦琐。
BigDecimal介绍
BigDecimal是Java提供的⼀个不变的、任意精度的有符号⼗进制数对象。它提供了四个构造器,有两个是⽤BigInteger构造,在这⾥我们不
关⼼,我们重点看⽤double和String构造的两个构造器(有关BigInteger详细介绍请查阅j2se API⽂档)。
BigDecimal(double val)
Translates a double into a BigDecimal.
BigDecimal(String val)
Translates the String representation of a BigDecimal into a BigDecimal.
BigDecimal(double)是把⼀个double类型⼗进制数构造为⼀个BigDecimal对象实例。
BigDecimal(String)是把⼀个以String表⽰的BigDecimal对象构造为BigDecimal对象实例。
习惯上,对于浮点数我们都会定义为double或float,但BigDecimal API⽂档中对于BigDecimal(double)有这么⼀段话:
Note: the results of this constructor can be somewhat unpredictable. One might assume that new BigDecimal(.1) is exactly equal to .1, but it is actually equal to .10000000000000000555111512312578 27021181583404541015625. This is so because .1 cannot be represented exactly as a double (or, for that matter, as a binary fraction of any finite length). Thus, the long value that is being passed in to the constructor is not exactly equal to .1, appearances notwithstanding.
The (String) constructor, on the other hand, is perfectly predictable: new BigDecimal(".1") is exactly equal to .1, as one would expect. Therefore, it is generally recommended that the (String) constructor
be used in preference to this one
下⾯对这段话做简单解释:
注意:这个构造器的结果可能会有不可预知的结果。有⼈可能设想new BigDecimal(.1)等于.1是正确的,但它实际上是等
于.1000000000000000055511151231257827021181583404541015625,这就是为什么.1不能⽤⼀个double精确表⽰的原因,因此,这个被放进构造器中的长值并不精确的等于.1,尽管外观看起来是相等的。
然⽽(String)构造器,则完全可预知的,new BigDecimal(“.1”)如同期望的那样精确的等于.1,因此,(String)构造器是被优先推荐使⽤的。
看下⾯的结果:
System.out.println(new BigDecimal(123456789.02).toString());
System.out.println(new BigDecimal("123456789.02").toString());
输出为:
123456789.01999999582767486572265625
123456789.02
现在我们知道,如果需要精确计算,⾮要⽤String来够造BigDecimal不可!
实现⽅案
现在我们已经知道怎么解决这个问题了,原则上是使⽤BigDecimal(String)构造器,我们建议,在商业应⽤开发中,涉及⾦额等浮点数计算的数据,全部定义为String,数据库中可定义为字符型字段,在需要使⽤这些数据进⾏运算的时候,使⽤BigDecimal(String)构造BigDecimal对象进⾏运算,保证数据的精确计算。同时避免了科学记数法的出现。如果科学记数表⽰法在应⽤中不是⼀种负担的话,可以考虑定义为浮点类型。
这⾥我们提供了⼀个⼯具类,定义浮点数的加、减、乘、除和四舍五⼊等运算⽅法。以供参考。
源⽂件MathExtend.java:
import java.math.BigDecimal;
public class MathExtend
{
//默认除法运算精度
private static final int DEFAULT_DIV_SCALE = 10;
/**
* 提供精确的加法运算。
* @param v1
* @param v2
* @return 两个参数的和
*/
public static double add(double v1, double v2)
{
BigDecimal b1 = new String(v1)); BigDecimal b2 = new String(v2)); return b1.add(b2).doubleValue();
}
/**
* 提供精确的加法运算
* @param v1
* @param v2
* @return 两个参数数学加和,以字符串格式返回
*/
public static String add(String v1, String v2)
{
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.add(b2).toString();
}
/**
* 提供精确的减法运算。
* @param v1
* @param v2
* @return 两个参数的差
*/
public static double subtract(double v1, double v2)
{
BigDecimal b1 = new String(v1)); BigDecimal b2 = new String(v2)); return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的减法运算
* @param v1
* @param v2
* @return 两个参数数学差,以字符串格式返回
*/
public static String subtract(String v1, String v2)
{
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.subtract(b2).toString();bigdecimal除法保留小数
}
/**
* 提供精确的乘法运算。
* @param v1
* @param v2
* @return 两个参数的积
*/
public static double multiply(double v1, double v2)
{
BigDecimal b1 = new String(v1)); BigDecimal b2 = new String(v2)); return b1.multiply(b2).doubleValue();
}
/**
* 提供精确的乘法运算
* @param v1
* @param v2
* @return 两个参数的数学积,以字符串格式返回
*/
public static String multiply(String v1, String v2)
{
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.multiply(b2).toString();
}
/**
版权声明:本站内容均来自互联网,仅供演示用,请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198,我们将在24小时内删除。
发表评论