android 有小数位的加减计算

android 金额,Android BigDecimal对金额进行精确计算 – 源码巴士

我们平常使用float或者double进行计算时会出现精度丢失的情况，例如：

system.out.println(0.06-0.01)

得到的结果为0.0499999999999999

为什么会出现这种情况呢？

原因在于我们的计算机是二进制的。浮点数没有办法是用二进制进行精确表示。我们的CPU表示浮点数由两个部分组成：指数和尾数，这样的表示方法一般都会失去一定的精确度，有些浮点数运算也会产生一定的误差。如：2.4的二进制表示并非就是精确的2.4。反而最为接近的二进制表示是 2.3999999999999999。浮点数的值实际上是由一个特定的数学公式计算得到的。

在这种情况下我们就需要用到java.math包下面的BigDecimal类，BigDecimal主要用于高精度的数据计算，例如计算金额的时候，还有工程测量计算的时候。BigDecimal的提供了add(),subtract(),multiply()和divide()四种方法，分别为加减乘除，用法为

BigDecimal b1 = new BigDecimal(Double或者String);

BigDecimal b2 = new BigDecimal(Double或者String);

System.out.println(b1.subtract(b2).doubleValue());

我在实际用的时候发现了一个问题，当在new BigDecimal()的时候，如果参数类型为Double，得到的结果仍然丢失了精度，例如：

BigDecimal b1 = new BigDecimal((Double)0.06);

BigDecimal b2 = new BigDecimal((Double)0.01);

System.out.println(b1.subtract(b2).doubleValue());

得到的结果仍然为0.0499999999999999999

可是如果参数类型为String,结果就是正确的，就像这样：

BigDecimal b1 = new BigDecimal("0.06");

BigDecimal b2 = new BigDecimal("0.01");

System.out.println(b1.subtract(b2).doubleValue());

得到的结果为0.05，所以如果大家要进行精确计算的话，new BigDecimal()的参数一定要用String类型的，至于为什么，我也不知道。

话不多说，直接上代码

public class BigDecimalUtils

{

//默认除法运算精度

private static final int DEF_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 加数

* @param scale 保留scale 位小数

* @return 两个参数的和

*/

public static String add(String v1, String v2, int scale) {

if (scale < 0) {

throw new IllegalArgumentException(

"保留的小数位数必须大于零");

}

BigDecimal b1 = new BigDecimal(v1);

BigDecimal b2 = new BigDecimal(v2);

return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();

}

/**

* 提供精确的减法运算

*

* @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 减数

* @param scale 保留scale 位小数

* @return 两个参数的差

*/

public static String sub(String v1, String v2, int scale) {

if (scale < 0) {

throw new IllegalArgumentException(

"保留的小数位数必须大于零");

}

BigDecimal b1 = new BigDecimal(v1);

BigDecimal b2 = new BigDecimal(v2);

return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();

}

/**

* 提供精确的乘法运算

*

* @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();

}

/**

* 提供精确的乘法运算

*

* @param v1 被乘数

* @param v2 乘数

* @param scale 保留scale 位小数

* @return 两个参数的积

*/

public static double mul(double v1, double v2, int scale) {

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

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

return round(b1.multiply(b2).doubleValue(), scale);

}

/**

* 提供精确的乘法运算

*

* @param v1 被乘数

* @param v2 乘数

* @param scale 保留scale 位小数

* @return 两个参数的积

*/

public static String mul(String v1, String v2, int scale) {

if (scale < 0) {

throw new IllegalArgumentException(

"保留的小数位数必须大于零");

}

BigDecimal b1 = new BigDecimal(v1);

BigDecimal b2 = new BigDecimal(v2);

return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();

}

/**

* 提供(相对)精确的除法运算，当发生除不尽的情况时，精确到

* 小数点以后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("保留的小数位数必须大于零");

}

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

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

return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();

}

/**

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

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

*

* @param v1 被除数

* @param v2 除数

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

* @return 两个参数的商

*/

public static String div(String v1, String v2, int scale) {

if (scale < 0) {

throw new IllegalArgumentException("保留的小数位数必须大于零");

}

BigDecimal b1 = new BigDecimal(v1);

BigDecimal b2 = new BigDecimal(v2);

return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();

}

/**

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

*

* @param v 需要四舍五入的数字

* @param scale 小数点后保留几位

* @return 四舍五入后的结果

*/

public static double round(double v, int scale) {

if (scale < 0) {

throw new IllegalArgumentException("保留的小数位数必须大于零");

}

BigDecimal b = new BigDecimal(Double.toString(v));

return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();

}

/**

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

*

* @param v 需要四舍五入的数字

* @param scale 小数点后保留几位

* @return 四舍五入后的结果

*/

public static String round(String v, int scale) {

if (scale < 0) {

throw new IllegalArgumentException(

"保留的小数位数必须大于零");

}

BigDecimal b = new BigDecimal(v);

return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();

}

/**

* 取余数

*

* @param v1 被除数

* @param v2 除数

* @param scale 小数点后保留几位

* @return 余数

*/

public static String remainder(String v1, String v2, int scale) {

if (scale < 0) {

throw new IllegalArgumentException(

"保留的小数位数必须大于零");

}

BigDecimal b1 = new BigDecimal(v1);

BigDecimal b2 = new BigDecimal(v2);

return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();

}

/**

* 比较大小

*

* @param v1 被比较数

* @param v2 比较数

* @return 如果v1 大于v2 则 返回true 否则false

*/

public static boolean compare(String v1, String v2) {

BigDecimal b1 = new BigDecimal(v1);

BigDecimal b2 = new BigDecimal(v2);

int bj = b1.compareTo(b2);

boolean res;

if (bj > 0)

res = true;

else

res = false;

return res;

}

}