makemyownlife
- 浏览: 532501 次
- 性别:
- 来自: 武汉
-
文章分类
最新评论
-
rgqancy：
终于明白为啥XML里要带jdbcType=XXXX了。
mybatis 需要注意的点 MyBatis 插入空值时，需要指定JdbcType (201 -
rzh0001：
Thanks a lot
mybatis 需要注意的点 MyBatis 插入空值时，需要指定JdbcType (201 -
guji528：
学习了，谢谢
mybatis 需要注意的点 MyBatis 插入空值时，需要指定JdbcType (201 -
AKka：
彻底清楚这个错误的原因了。向楼主学习了。
mybatis 需要注意的点 MyBatis 插入空值时，需要指定JdbcType (201 -
远去的渡口：
武汉小吃，我最爱热干面和鸭脖，想念啊~~
过年时候还学习编程， ...
过年的心情
问题提出
（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中也没有提供保留指定位数的四舍五入方法，只提供了一个Math.round(double d)和Math.round(float f)的方法，分别返回长整型和整型值。round方法不能设置保留几位小数，我们只能象这样（保留两位）：
public double round(double value){
return Math.round( value * 100 ) / 100.0;
}
但非常不幸的是，上面的代码并不能正常工作，给这个方法传入4.015它将返回4.01而不是4.02，如我们在上面看到的
4.015 * 100 = 401.49999999999994
因此如果我们要做到精确的四舍五入，这种方法不能满足我们的要求。
还有一种方式是使用java.text.DecimalFormat，但也存在问题，format采用的舍入模式是ROUND_HALF_DOWN（舍入模式在下面有介绍），比如说4.025保留两位小数会是4.02，因为.025距离” nearest neighbor”（.02和.03）长度是相等，向下舍入就是.02，如果是4.0251那么保留两位小数就是4.03。
System.out.println(new java.text.DecimalFormat("0.00").format(4.025));
System.out.println(new java.text.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 BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(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 BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(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();
}
/**
* 提供精确的乘法运算。
* @param v1
* @param v2
* @return 两个参数的积
*/
public static double multiply(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(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();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_EVEN
* @param v1
* @param v2
* @return 两个参数的商
*/
public static double divide(double v1, double v2)
{
return divide(v1, v2, DEFAULT_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double divide(double v1,double v2, int scale)
{
return divide(v1, v2, scale, BigDecimal.ROUND_HALF_EVEN);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位
* @param round_mode 表示用户指定的舍入模式
* @return 两个参数的商
*/
public static double divide(double v1,double v2,int scale, int round_mode){
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, round_mode).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_EVEN
* @param v1
* @param v2
* @return 两个参数的商，以字符串格式返回
*/
public static String divide(String v1, String v2)
{
return divide(v1, v2, DEFAULT_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位
* @return 两个参数的商，以字符串格式返回
*/
public static String divide(String v1, String v2, int scale)
{
return divide(v1, v2, DEFAULT_DIV_SCALE, BigDecimal.ROUND_HALF_EVEN);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位
* @param round_mode 表示用户指定的舍入模式
* @return 两个参数的商，以字符串格式返回
*/
public static String divide(String v1, String v2, int scale, int round_mode)
{
if(scale < 0)
{
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.divide(b2, scale, round_mode).toString();
}
/**
* 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v,int scale)
{
return round(v, scale, BigDecimal.ROUND_HALF_EVEN);
}
/**
* 提供精确的小数位四舍五入处理
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @param round_mode 指定的舍入模式
* @return 四舍五入后的结果
*/
public static double round(double v, int scale, int round_mode)
{
if(scale<0)
{
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
return b.setScale(scale, round_mode).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果，以字符串格式返回
*/
public static String round(String v, int scale)
{
return round(v, scale, BigDecimal.ROUND_HALF_EVEN);
}
/**
* 提供精确的小数位四舍五入处理
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @param round_mode 指定的舍入模式
* @return 四舍五入后的结果，以字符串格式返回
*/
public static String round(String v, int scale, int round_mode)
{
if(scale<0)
{
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(v);
return b.setScale(scale, round_mode).toString();
}
}
BigDecimal 舍入模式（Rounding mode）介绍：
BigDecimal定义了一下舍入模式，只有在作除法运算或四舍五入时才用到舍入模式，下面简单介绍，详细请查阅J2se API文档
static int
ROUND_CEILING
Rounding mode to round towards positive infinity.
向正无穷方向舍入
static int
ROUND_DOWN
Rounding mode to round towards zero.
向零方向舍入
static int
ROUND_FLOOR
Rounding mode to round towards negative infinity.
向负无穷方向舍入
static int
ROUND_HALF_DOWN
Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down.
向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5
static int
ROUND_HALF_EVEN
Rounding mode to round towards the "nearest neighbor" unless both neighbors are equidistant, in which case, round towards the even neighbor.
向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用ROUND_HALF_UP ，如果是偶数，使用ROUND_HALF_DOWN
static int
ROUND_HALF_UP
Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up.
向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6
static int
ROUND_UNNECESSARY
Rounding mode to assert that the requested operation has an exact result, hence no rounding is necessary.
计算结果是精确的，不需要舍入模式
static int
ROUND_UP
Rounding mode to round away from zero.
向远离0的方向舍入
（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中也没有提供保留指定位数的四舍五入方法，只提供了一个Math.round(double d)和Math.round(float f)的方法，分别返回长整型和整型值。round方法不能设置保留几位小数，我们只能象这样（保留两位）：
public double round(double value){
return Math.round( value * 100 ) / 100.0;
}
但非常不幸的是，上面的代码并不能正常工作，给这个方法传入4.015它将返回4.01而不是4.02，如我们在上面看到的
4.015 * 100 = 401.49999999999994
因此如果我们要做到精确的四舍五入，这种方法不能满足我们的要求。
还有一种方式是使用java.text.DecimalFormat，但也存在问题，format采用的舍入模式是ROUND_HALF_DOWN（舍入模式在下面有介绍），比如说4.025保留两位小数会是4.02，因为.025距离” nearest neighbor”（.02和.03）长度是相等，向下舍入就是.02，如果是4.0251那么保留两位小数就是4.03。
System.out.println(new java.text.DecimalFormat("0.00").format(4.025));
System.out.println(new java.text.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 BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(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 BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(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();
}
/**
* 提供精确的乘法运算。
* @param v1
* @param v2
* @return 两个参数的积
*/
public static double multiply(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(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();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_EVEN
* @param v1
* @param v2
* @return 两个参数的商
*/
public static double divide(double v1, double v2)
{
return divide(v1, v2, DEFAULT_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double divide(double v1,double v2, int scale)
{
return divide(v1, v2, scale, BigDecimal.ROUND_HALF_EVEN);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位
* @param round_mode 表示用户指定的舍入模式
* @return 两个参数的商
*/
public static double divide(double v1,double v2,int scale, int round_mode){
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, round_mode).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_EVEN
* @param v1
* @param v2
* @return 两个参数的商，以字符串格式返回
*/
public static String divide(String v1, String v2)
{
return divide(v1, v2, DEFAULT_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位
* @return 两个参数的商，以字符串格式返回
*/
public static String divide(String v1, String v2, int scale)
{
return divide(v1, v2, DEFAULT_DIV_SCALE, BigDecimal.ROUND_HALF_EVEN);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
* @param v1
* @param v2
* @param scale 表示需要精确到小数点以后几位
* @param round_mode 表示用户指定的舍入模式
* @return 两个参数的商，以字符串格式返回
*/
public static String divide(String v1, String v2, int scale, int round_mode)
{
if(scale < 0)
{
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.divide(b2, scale, round_mode).toString();
}
/**
* 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v,int scale)
{
return round(v, scale, BigDecimal.ROUND_HALF_EVEN);
}
/**
* 提供精确的小数位四舍五入处理
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @param round_mode 指定的舍入模式
* @return 四舍五入后的结果
*/
public static double round(double v, int scale, int round_mode)
{
if(scale<0)
{
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
return b.setScale(scale, round_mode).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果，以字符串格式返回
*/
public static String round(String v, int scale)
{
return round(v, scale, BigDecimal.ROUND_HALF_EVEN);
}
/**
* 提供精确的小数位四舍五入处理
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @param round_mode 指定的舍入模式
* @return 四舍五入后的结果，以字符串格式返回
*/
public static String round(String v, int scale, int round_mode)
{
if(scale<0)
{
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(v);
return b.setScale(scale, round_mode).toString();
}
}
BigDecimal 舍入模式（Rounding mode）介绍：
BigDecimal定义了一下舍入模式，只有在作除法运算或四舍五入时才用到舍入模式，下面简单介绍，详细请查阅J2se API文档
static int
ROUND_CEILING
Rounding mode to round towards positive infinity.
向正无穷方向舍入
static int
ROUND_DOWN
Rounding mode to round towards zero.
向零方向舍入
static int
ROUND_FLOOR
Rounding mode to round towards negative infinity.
向负无穷方向舍入
static int
ROUND_HALF_DOWN
Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down.
向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5
static int
ROUND_HALF_EVEN
Rounding mode to round towards the "nearest neighbor" unless both neighbors are equidistant, in which case, round towards the even neighbor.
向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用ROUND_HALF_UP ，如果是偶数，使用ROUND_HALF_DOWN
static int
ROUND_HALF_UP
Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up.
向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6
static int
ROUND_UNNECESSARY
Rounding mode to assert that the requested operation has an exact result, hence no rounding is necessary.
计算结果是精确的，不需要舍入模式
static int
ROUND_UP
Rounding mode to round away from zero.
向远离0的方向舍入
分享到：
发表评论
-
四位计算机的原理及其实现
2015-09-05 19:23 938你是否想过，计算机为什么会加减乘除？或者更直接一点，计算机的原 ... -
ubuntu13.04安装mysql5.6RPM包1、使用的安装包MySQL-5.6.12-2.l
2014-11-20 23:08 1028ubuntu13.04安装mysql5.6 RPM包 1、 ... -
字典树相关代码
2014-08-10 18:21 1008package com.myway.study; i ... -
两有序数组求交集
2014-05-01 00:27 1073package com.myway.study; i ... -
JVM垃圾收集器异同
2014-04-22 09:48 1266VM 垃圾收集器有3类，这里主要介绍我们常用的 并行和并发收集 ... -
idea 11 如何实现热部署
2014-02-17 13:37 1042idea 如何配置 热部署呢？ 如图： 然后配置 t ... -
java位操作符总结
2013-08-04 20:42 933二进制负数以它正值的 ... -
快速排序简要算法
2013-07-21 22:21 1111package math; import jav ... -
memcached安装
2013-03-10 09:32 4859今天 ，心血来潮 想安装下memcached 先给自己测试一下 ... -
温习温习 aop的原理
2013-02-11 22:23 1436在我工作这几年里，spring aop 用得最多的有两点 1 ... -
URL编码以及GET和POST提交乱码解决方案
2012-09-14 16:59 16941. 什么是URL编码。 ... -
Struts2 IF 判断 SESSION值
2012-08-16 15:12 1208<s:if test="ticke ... -
@me 如何处理
2012-07-28 22:37 1165红薯 分享了这个代码 ，我觉得很好 在这个社区与大家分享 。 ... -
mybatis 需要注意的点 MyBatis 插入空值时，需要指定JdbcType (201
2012-07-27 22:59 161762前天遇到一个问题 异常显示如下： 引用 Exception i ... -
猜测 javaye的分页设计
2012-07-05 21:32 1136非常喜欢javaeye的分页 ，自己也写了一个 按照逻辑测试了 ... -
java控制事务级别
2012-06-18 20:40 1167JDBC事务并发产生的问题和事务隔离级别 原子操作使用事务，一 ... -
ibatis / mybatis 存储过程调用 区别 以及例子
2012-06-11 21:16 1582ibatis： 如下： xml配置文件： 请看 ... -
java timerTask timer分析
2012-06-07 20:37 1569首先看一看 timer timerTask如何调用 ？ ... -
MapWrapper 学习
2012-01-04 16:25 1574MetaObject 有一个 setValue方法 这个方 ... -
mybatis 学习
2011-12-24 22:59 2444这篇博客是我学习mybatis的心得。也是对自己的鞭策。 这些 ...
相关推荐
为了解决这个问题，开发者们引入了`BigDecimal`类库的概念，它在Java中被广泛使用，用于进行高精度的算术运算。本文将详细介绍JavaScript版的`BigDecimal`类库，以及如何在JavaScript环境中实现精确计算。 ...
为了解决这个问题，开发者通常会引入第三方库，比如"BigDecimal.js"。这个库提供了一个名为`BigDecimal`的数据类型，用于实现大数运算，确保结果的精度不受损失。 "BigDecimal.js.zip"是一个压缩包，其中包含了...
BigDecimal工具类 BigDecimal工具类是Java中用于高精确处理常用数学运算的工具类。该工具类提供了多种精确的数学运算方法，包括加法、减法、乘法和除法等。 在BigDecimal工具类中，我们可以看到多个重载的方法，...
alert(new BigDecimal("10").add(new BigDecimal("3E+10"))); //- alert(new BigDecimal("10").subtract(new BigDecimal("3E+10"))); //* alert(new BigDecimal("10").multiply(new BigDecimal("3E+10"))); // / ...
BigDecimal b1=new BigDecimal("1.0"); BigDecimal b2=new BigDecimal("1.00"); boolean t=b1.equals(b2); 怎么样，你认为t是true还是false？它还真是false。BigDecimal的大小比较，1.0与1.00是不相等的，得采用...
在Java编程语言中，`BigInteger`和`BigDecimal`是两个重要的类，它们分别用于处理大整数和高精度浮点数。这两个类位于`java.math`包下，为开发者提供了超越基本数据类型（如int、long和double）的计算能力。在深入...
在 Java 编程中，`BigDecimal` 和 `Integer` 是两个不同类型的数值表示。`BigDecimal` 用于处理精确的浮点数运算，适合财务或金融计算，因为它可以避免浮点数计算中的精度问题。而 `Integer` 是 Java 中的整数类型，...
在Java编程中，当涉及到需要精确数值计算的场景时，我们通常会使用`BigDecimal`类。这是因为`float`和`double`类型虽然适用于科学计算和工程计算，但它们基于二进制浮点运算，不能保证完全精确的结果。而`BigDecimal...
在Java编程语言中，BigDecimal是一种用于处理高精度数值的数据类型，尤其适用于金融计算等领域，因为它可以提供不受限的小数位数精度以及精确的数学运算能力。然而，在某些情况下，我们可能需要将BigDecimal类型的值...
"js_bigdecimal_1_0_1.zip"是一个包含了JavaScript环境下实现BigDecimal功能的库，版本号为1.0.1，据描述，这个库经过了实际测试，证明是有效的。 BigDecimal是一种可以表示任意精度的十进制浮点数的类，主要用于...
这可能包括加法（BigDecimal.add()）、减法（BigDecimal.subtract()）、乘法（BigDecimal.multiply()）或除法（BigDecimal.divide()）操作。注意，BigDecimal的除法默认可能会抛出ArithmeticException，所以我们需要...
BigDecimal 类在 Java 中被设计用来处理高精度的浮点数运算，主要应用于财务、金融等领域，因为这些场景中对精度要求非常高。BigDecimal 提供了加法（add()）、减法（subtract()）、乘法（multiply()）和除法...
在Java编程语言中，BigDecimal是用于处理高精度和可配置精度的十进制数的类。在进行商业计算时，由于浮点数(double和float)存在精度问题，不能保证准确的结果，因此通常推荐使用BigDecimal来确保计算的精确性。本文...
BigDecimal 类详解 BigDecimal 类是 Java 中的一种数值类型，主要用于处理超过 16 位有效数字的数值运算。该类提供了多种构造器和方法，用于创建和操作 BigDecimal 对象。 构造器 BigDecimal 类提供了四种构造器...
标题中的"BigDecimal-CPP-master.zip"表明这是一个与BigDecimal类实现相关的C++项目压缩包。BigDecimal是一种可以处理任意精度的十进制浮点数的数据类型，它通常用于金融或会计等需要高精度计算的领域，因为在这些...
Java中BigInteger的数学运算,BigDecimal 加减乘除运算,Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大...
### BigDecimal的计算 #### 概述 在Java中，`BigDecimal` 类提供了对超过16位有效数字的十进制数进行精确算术运算的能力。它适用于金融计算、科学计算等场景，在这些场景中，使用浮点数（如 `float` 和 `double`）...
BigDecimal 类型是 Java 提供的一种用于精确算术运算的类，它支持任意大小的十进制数，并且能够避免浮点数计算时可能出现的舍入误差。然而，有时我们需要将这些大数转换为整数类型，如 Integer，以便于存储或者进行...
在Java编程语言中，BigDecimal类是用于处理高精度、大范围浮点数的工具，它在需要精确计算的场景下非常关键。BigDecimal提供了避免浮点数运算中的精度损失的方法，适用于金融、会计等对精度有严格要求的领域。这篇...