关键词搜索

源码搜索 ×
×

Java 使用BigDecimal实现精确计算

发布2016-11-28浏览2350次

详情内容

前言：程序中很多业务都会涉及到双精度Double数的计算，在计算过程中有很多问题是潜在的陷阱，使得程序不会按照我们预想的那样能够精确输出。

1.错误示例

先来看一个测试例子：

  1. package com.boonya.program.lang;
  2.  
  3. import java.math.BigDecimal;
  4.  
  5. import org.junit.Test;
  6.  
  7. public class BigDecimalTest {
  8. 	
  9. 	private static double a = 2.00;
  10. 	
  11. 	private static double b = 1.10; 
  12. 	
  13. 	@Test
  14. 	public void testSubstract0(){
  15. 		System.out.println("method=testSubstract0>:"+(a - b));// 输出0.8999999999999999
  16. 	}
  17. 	
  18. 	@Test
  19. 	public void testSubstract1(){
  20. 		BigDecimal a1=new BigDecimal(a);
  21. 		BigDecimal b1=new BigDecimal(b);
  22. 		double result=a1.subtract(b1).doubleValue();
  23. 		System.out.println("method=testSubstract1>:"+result);// 输出0.8999999999999999
  24. 	}
  25. 	
  26. 	@Test
  27. 	public void testSubstract2(){
  28. 		BigDecimal a1=new BigDecimal(Double.valueOf(a));
  29. 		BigDecimal b1=new BigDecimal(Double.valueOf(b));
  30. 		double result=a1.subtract(b1).doubleValue();
  31. 		System.out.println("method=testSubstract2>:"+result);// 输出0.8999999999999999
  32. 	}
  33. 	
  34. 	@Test
  35. 	public void testSubstract3(){
  36. 		BigDecimal a1=new BigDecimal(Double.toString(a));
  37. 		BigDecimal b1=new BigDecimal(Double.toString(b));
  38. 		double result=a1.subtract(b1).doubleValue();
  39. 		System.out.println("method=testSubstract3>:"+result);// 输出0.9
  40. 	}
  41. 	
  42.  
  43. }

从上面可以看出，testSubstract3 方法输出的结果才是我们所预期的。

2.Double计算原理

《Effactive Java》书中说，float和double类型的主要设计目标是为了科学计算和工程计算。他们执行二进制浮点运算，这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的。然而，它们没有提供完全精确的结果，所以不应该被用于要求精确结果的场合。但是，商业计算往往要求结果精确，这时候BigDecimal就派上大用场啦。

在JDK的描述中：

1、参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。

2、另一方面，String 构造方法是完全可预知的：写入 newBigDecimal("0.1") 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言，通常建议优先使用String构造方法。

3、当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。要获取该结果，请使用static valueOf(double)方法。

3.BigDecimal计算工具

此工具类参考过网上的例子，但是其大部分都是错误的，其人使用的是：

BigDecimal b1 = new BigDecimal(Double.valueOf(value1));

在实际的计算中是错误的。下面是工具类的代码：

  1. package com.boonya.program.lang;
  2.  
  3. import java.math.BigDecimal;
  4. import java.math.BigInteger;
  5. /**
  6.  * BigDecimal精确计算:参考http://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html
  7.  * 
  8.  * <li>在大多数的商业计算中，一般采用java.math.BigDecimal类来进行精确计算。</li>
  9.  * @package com.boonya.program.lang.BBigDecimal
  10.  * @date   2016年11月28日  上午11:33:44
  11.  * @author pengjunlin
  12.  * @comment   
  13.  * @update
  14.  */
  15. public class BBigDecimal extends BigDecimal{
  16. 	
  17. 	/**
  18. 	 * 
  19. 	 */
  20. 	private static final long serialVersionUID = -8187328246570289879L;
  21.  
  22. 	public BBigDecimal(BigInteger val) {
  23. 		super(val);
  24. 	}
  25.  
  26. 	/**
  27. 	 * 提供精确加法计算的add方法
  28. 	 * 
  29. 	 * @param value1
  30. 	 *            被加数
  31. 	 * @param value2
  32. 	 *            加数
  33. 	 * @return 两个参数的和
  34. 	 */
  35. 	public static double add(double value1, double value2) {
  36. 		BigDecimal a = new BigDecimal(Double.toString(value1));
  37. 		BigDecimal b = new BigDecimal(Double.toString(value2));
  38. 		return a.add(b).doubleValue();
  39. 	}
  40. 	
  41. 	/**
  42. 	 * 提供精确加法计算的add方法
  43. 	 * 
  44. 	 * @param value1
  45. 	 *            被加数
  46. 	 * @param value2
  47. 	 *            加数
  48. 	 * @param scale
  49. 	 *            精确范围
  50. 	 * @return 两个参数的和
  51. 	 * @throws IllegalAccessException 
  52. 	 */
  53. 	public static double add(double value1, double value2,int scale) throws IllegalAccessException {
  54. 		BigDecimal a = new BigDecimal(Double.toString(value1));
  55. 		BigDecimal b = new BigDecimal(Double.toString(value2));
  56. 		// 如果精确范围小于0，抛出异常信息
  57. 		if(scale<0){
  58. 			throw new IllegalAccessException("精确度不能小于0");
  59. 		}
  60. 		a=a.setScale(scale);//必须重新赋值
  61. 		b=b.setScale(scale);//必须重新赋值
  62. 		return a.add(b).setScale(scale).doubleValue();
  63. 	}
  64.  
  65. 	/**
  66. 	 * 提供精确减法运算的subtract方法
  67. 	 * 
  68. 	 * @param value1
  69. 	 *            被减数
  70. 	 * @param value2
  71. 	 *            减数
  72. 	 * @return 两个参数的差
  73. 	 */
  74. 	public static double subtract(double value1, double value2) {
  75. 		BigDecimal a = new BigDecimal(Double.toString(value1));
  76. 		BigDecimal b = new BigDecimal(Double.toString(value2));
  77. 		return a.subtract(b).doubleValue();
  78. 	}
  79. 	
  80. 	/**
  81. 	 * 提供精确减法运算的subtract方法
  82. 	 * 
  83. 	 * @param value1
  84. 	 *            被减数
  85. 	 * @param value2
  86. 	 *            减数
  87. 	 * @param scale
  88. 	 *            精确范围
  89. 	 * @return 两个参数的差
  90. 	 * @throws IllegalAccessException 
  91. 	 */
  92. 	public static double subtract(double value1, double value2,int scale) throws IllegalAccessException {
  93. 		BigDecimal a = new BigDecimal(Double.toString(value1));
  94. 		BigDecimal b = new BigDecimal(Double.toString(value2));
  95. 		// 如果精确范围小于0，抛出异常信息
  96. 		if(scale<0){
  97. 			throw new IllegalAccessException("精确度不能小于0");
  98. 		}
  99. 		a=a.setScale(scale);//必须重新赋值
  100. 		b=b.setScale(scale);//必须重新赋值
  101. 		return a.subtract(b).setScale(scale).doubleValue();
  102. 	}
  103.  
  104. 	/**
  105. 	 * 提供精确乘法运算的multiply方法
  106. 	 * 
  107. 	 * @param value1
  108. 	 *            被乘数
  109. 	 * @param value2
  110. 	 *            乘数
  111. 	 * @return 两个参数的积
  112. 	 */
  113. 	public static double multiply(double value1, double value2) {
  114. 		BigDecimal a = new BigDecimal(Double.toString(value1));
  115. 		BigDecimal b = new BigDecimal(Double.toString(value2));
  116. 		return a.multiply(b).doubleValue();
  117. 	}
  118. 	
  119. 	/**
  120. 	 * 提供精确乘法运算的multiply方法
  121. 	 * 
  122. 	 * @param value1
  123. 	 *            被乘数
  124. 	 * @param value2
  125. 	 *            乘数
  126. 	 * @param scale
  127. 	 *            精确范围
  128. 	 * @return 两个参数的积 
  129. 	 * @throws IllegalAccessException 
  130. 	 */
  131. 	public static double multiply(double value1, double value2,int scale) throws IllegalAccessException {
  132. 		BigDecimal a = new BigDecimal(Double.toString(value1));
  133. 		BigDecimal b = new BigDecimal(Double.toString(value2));
  134. 		// 如果精确范围小于0，抛出异常信息
  135. 		if(scale<0){
  136. 			throw new IllegalAccessException("精确度不能小于0");
  137. 		}
  138. 		a=a.setScale(scale);//必须重新赋值
  139. 		b=b.setScale(scale);//必须重新赋值
  140. 		return a.multiply(b).setScale(scale).doubleValue();
  141. 	}
  142. 	
  143. 	/**
  144. 	 * 提供精确的除法运算方法divide
  145. 	 * 
  146. 	 * @param value1
  147. 	 *            被除数
  148. 	 * @param value2
  149. 	 *            除数
  150. 	 * @param scale
  151. 	 *            精确范围
  152. 	 * @return 两个参数的商
  153. 	 * @throws IllegalAccessException
  154. 	 */
  155. 	public static double divide(double value1, double value2, int scale)
  156. 			throws IllegalAccessException {
  157. 		BigDecimal a = new BigDecimal(Double.toString(value1));
  158. 		BigDecimal b = new BigDecimal(Double.toString(value2));
  159. 		// 如果精确范围小于0，抛出异常信息
  160. 		if (scale < 0) {
  161. 			throw new IllegalAccessException("精确度不能小于0");
  162. 		}
  163. 		a=a.setScale(scale);//必须重新赋值
  164. 		b=b.setScale(scale);//必须重新赋值
  165. 		return a.divide(b,scale).doubleValue();
  166. 	}
  167.  
  168.  
  169. }

4.总结

        (1)商业数据计算使用BigDecimal。

        (2)尽量使用参数类型为String的构造函数。

        (3) BigDecimal都是不可变的（immutable）的，在进行每一步运算时，都会产生一个新的对象，所以在做加减乘除运算时千万要保存操作后的值。

        (4)我们往往容易忽略JDK底层的一些实现细节，导致出现错误，需要多加注意。

参考博客地址： http://blog.csdn.net/jackiehff/article/details/8582449

相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载