BigDecimal 概述

Java 在 java.math 包中提供的 API 类 BigDecimal,用来对超过 16 位有效位的数进行精确的运算。双精度浮点型变量 double 可以处理 16 位有效数,但在实际应用中,可能需要对更大或者更小的数进行运算和处理。一般情况下,对于那些不需要准确计算精度的数字,我们可以直接使用 Float 和 Double 处理,但是 Double.valueOf(String)Float.valueOf(String) 会丢失精度。所以开发中,如果我们需要精确计算的结果,则必须使用 BigDecimal 类来操作。

BigDecimal 所创建的是对象,故我们不能使用传统的 “+”、“-”、“*”、“/” 等算术运算符直接对其对象进行数学运算,而必须调用其相对应的方法。方法中的参数也必须是 BigDecimal 的对象。构造器是类的特殊方法,专门用来创建对象,特别是带有参数的对象。

BigDecimal 常用构造函数

常用构造函数

  • BigDecimal(int)
    创建一个具有参数所指定整数值的对象
  • BigDecimal(double)
    创建一个具有参数所指定双精度值的对象
  • BigDecimal(long)
    创建一个具有参数所指定长整数值的对象
  • BigDecimal(String)
    创建一个具有参数所指定以字符串表示的数值的对象

使用问题分析

使用示例:

  1. BigDecimal a =new BigDecimal(0.1);
  2. System.out.println("a values is:"+a);
  3. System.out.println("=====================");
  4. BigDecimal b =new BigDecimal("0.1");
  5. System.out.println("b values is:"+b);

结果示例:

  1. a values is:0.1000000000000000055511151231257827021181583404541015625
  2. b values is:0.1

原因分析:

  • 参数类型为 double 的构造方法的结果有一定的不可预知性。有人可能认为在 Java 中写入 newBigDecimal(0.1)所创建的 BigDecimal 正好等于 0.1(非标度值 1,其标度为 1),但是它实际上等于 0.1000000000000000055511151231257827021181583404541015625。这是因为 0.1 无法准确地表示为 double(或者说对于该情况,不能表示为任何有限长度的二进制小数)。这样,传入到构造方法的值不会正好等于 0.1(虽然表面上等于该值)。
  • String 构造方法是完全可预知的:写入 newBigDecimal(“0.1”) 将创建一个 BigDecimal,它正好等于预期的 0.1。因此,比较而言, 通常建议优先使用 String 构造方法。
  • 当 double 必须用作 BigDecimal 的源时,请注意,此构造方法提供了一个准确转换;它不提供与以下操作相同的结果:先使用 Double.toString(double) 方法,然后使用 BigDecimal(String) 构造方法,将 double 转换为 String。要获取该结果,请使用 static valueOf(double) 方法。

BigDecimal 常用方法详解

常用方法

  • add(BigDecimal)
    BigDecimal 对象中的值相加,返回 BigDecimal 对象
  • subtract(BigDecimal)
    BigDecimal 对象中的值相减,返回 BigDecimal 对象
  • multiply(BigDecimal)
    BigDecimal 对象中的值相乘,返回 BigDecimal 对象
  • divide(BigDecimal)
    BigDecimal 对象中的值相除,返回 BigDecimal 对象
  • toString()
    将 BigDecimal 对象中的值转换成字符串
  • doubleValue()
    将 BigDecimal 对象中的值转换成双精度数
  • floatValue()
    将 BigDecimal 对象中的值转换成单精度数
  • longValue()
    将 BigDecimal 对象中的值转换成长整数
  • intValue()
    将 BigDecimal 对象中的值转换成整数

BigDecimal 大小比较

java 中对 BigDecimal 比较大小一般用的是 bigdemical 的 compareTo 方法

  1. int a = bigdemical.compareTo(bigdemical2);

返回结果分析:

  1. a = -1,表示 bigdemical 小于 bigdemical2;
  2. a = 0,表示 bigdemical 等于 bigdemical2;
  3. a = 1,表示 bigdemical 大于 bigdemical2;

举例:a 大于等于 b

  1. new bigdemica(a).compareTo(new bigdemical(b)) >= 0;

BigDecimal 格式化

由于 NumberFormat 类的 format()方法可以使用 BigDecimal 对象作为其参数,可以利用 BigDecimal 对超出 16 位有效数字的货币值,百分值,以及一般数值进行格式化控制。

以利用 BigDecimal 对货币和百分比格式化为例。首先,创建 BigDecimal 对象,进行 BigDecimal 的算术运算后,分别建立对货币和百分比格式化的引用,最后利用 BigDecimal 对象作为 format()方法的参数,输出其格式化的货币值和百分比。

  1. NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用
  2. NumberFormat percent = NumberFormat.getPercentInstance(); //建立百分比格式化引用
  3. percent.setMaximumFractionDigits(3); //百分比小数点最多3位
  4. BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额
  5. BigDecimal interestRate = new BigDecimal("0.008"); //利率
  6. BigDecimal interest = loanAmount.multiply(interestRate); //相乘
  7. System.out.println("贷款金额:\t" + currency.format(loanAmount));
  8. System.out.println("利率:\t" + percent.format(interestRate));
  9. System.out.println("利息:\t" + currency.format(interest));

结果:

  1. 贷款金额: 15,000.48
  2. 利率: 0.8%
  3. 利息: 120.00

BigDecimal 格式化保留 2 为小数,不足则补 0:

  1. public class NumberFormat {
  2. public static void main(String[] s) {
  3. System.out.println(formatToNumber(new BigDecimal("3.435")));
  4. System.out.println(formatToNumber(new BigDecimal(0)));
  5. System.out.println(formatToNumber(new BigDecimal("0.00")));
  6. System.out.println(formatToNumber(new BigDecimal("0.001")));
  7. System.out.println(formatToNumber(new BigDecimal("0.006")));
  8. System.out.println(formatToNumber(new BigDecimal("0.206")));
  9. }
  10. /**
  11. * @desc 1.0~1之间的BigDecimal小数,格式化后失去前面的0,则前面直接加上0。 2.传入的参数等于0,则直接返回字符串"0.00"
  12. * 3.大于1的小数,直接格式化返回字符串
  13. * @param obj传入的小数
  14. * @return
  15. */
  16. public static String formatToNumber(BigDecimal obj) {
  17. DecimalFormat df = new DecimalFormat("#.00");
  18. if (obj.compareTo(BigDecimal.ZERO) == 0) {
  19. return "0.00";
  20. } else if (obj.compareTo(BigDecimal.ZERO) > 0 && obj.compareTo(new BigDecimal(1)) < 0) {
  21. return "0" + df.format(obj).toString();
  22. } else {
  23. return df.format(obj).toString();
  24. }
  25. }
  26. }

结果为:

  1. 3.44
  2. 0.00
  3. 0.00
  4. 0.00
  5. 0.01
  6. 0.21

BigDecimal 常见异常

除法的时候出现异常

  1. java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result

原因分析

通过 BigDecimal 的 divide 方法进行除法时当不整除,出现无限循环小数时,就会抛异常:
java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

解决方法

divide 方法设置精确的小数点,如:divide(xxxxx,2)

BigDecimal 总结

总结

  • 在需要精确的小数计算时再使用 BigDecimal,BigDecimal 的性能比 double 和 float 差,在处理庞大,复杂的运算时尤为明显。故一般精度的计算没必要使用 BigDecimal。
  • 尽量使用参数类型为 String 的构造函数。
  • BigDecimal 都是不可变的(immutable)的, 在进行每一次四则运算时,都会产生一个新的对象 ,所以在做加减乘除运算时要记得要保存操作后的值。

工具类推荐

  1. import java.math.BigDecimal;
  2. /**
  3. * 用于高精确处理常用的数学运算
  4. */
  5. public class ArithmeticUtils {
  6. // 默认除法运算精度
  7. private static final int DEF_DIV_SCALE = 10;
  8. /**
  9. * 提供精确的加法运算
  10. *
  11. * @param v1 被加数
  12. * @param v2 加数
  13. * @return 两个参数的和
  14. */
  15. public static double add(double v1, double v2) {
  16. BigDecimal b1 = new BigDecimal(Double.toString(v1));
  17. BigDecimal b2 = new BigDecimal(Double.toString(v2));
  18. return b1.add(b2).doubleValue();
  19. }
  20. /**
  21. * 提供精确的加法运算
  22. *
  23. * @param v1 被加数
  24. * @param v2 加数
  25. * @return 两个参数的和
  26. */
  27. public static BigDecimal add(String v1, String v2) {
  28. BigDecimal b1 = new BigDecimal(v1);
  29. BigDecimal b2 = new BigDecimal(v2);
  30. return b1.add(b2);
  31. }
  32. /**
  33. * 提供精确的加法运算
  34. *
  35. * @param v1 被加数
  36. * @param v2 加数
  37. * @param scale 保留scale 位小数
  38. * @return 两个参数的和
  39. */
  40. public static String add(String v1, String v2, int scale) {
  41. if (scale < 0) {
  42. throw new IllegalArgumentException("The scale must be a positive integer or zero");
  43. }
  44. BigDecimal b1 = new BigDecimal(v1);
  45. BigDecimal b2 = new BigDecimal(v2);
  46. return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  47. }
  48. /**
  49. * 提供精确的减法运算
  50. *
  51. * @param v1 被减数
  52. * @param v2 减数
  53. * @return 两个参数的差
  54. */
  55. public static double sub(double v1, double v2) {
  56. BigDecimal b1 = new BigDecimal(Double.toString(v1));
  57. BigDecimal b2 = new BigDecimal(Double.toString(v2));
  58. return b1.subtract(b2).doubleValue();
  59. }
  60. /**
  61. * 提供精确的减法运算。
  62. *
  63. * @param v1 被减数
  64. * @param v2 减数
  65. * @return 两个参数的差
  66. */
  67. public static BigDecimal sub(String v1, String v2) {
  68. BigDecimal b1 = new BigDecimal(v1);
  69. BigDecimal b2 = new BigDecimal(v2);
  70. return b1.subtract(b2);
  71. }
  72. /**
  73. * 提供精确的减法运算
  74. *
  75. * @param v1 被减数
  76. * @param v2 减数
  77. * @param scale 保留scale 位小数
  78. * @return 两个参数的差
  79. */
  80. public static String sub(String v1, String v2, int scale) {
  81. if (scale < 0) {
  82. throw new IllegalArgumentException("The scale must be a positive integer or zero");
  83. }
  84. BigDecimal b1 = new BigDecimal(v1);
  85. BigDecimal b2 = new BigDecimal(v2);
  86. return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  87. }
  88. /**
  89. * 提供精确的乘法运算
  90. *
  91. * @param v1 被乘数
  92. * @param v2 乘数
  93. * @return 两个参数的积
  94. */
  95. public static double mul(double v1, double v2) {
  96. BigDecimal b1 = new BigDecimal(Double.toString(v1));
  97. BigDecimal b2 = new BigDecimal(Double.toString(v2));
  98. return b1.multiply(b2).doubleValue();
  99. }
  100. /**
  101. * 提供精确的乘法运算
  102. *
  103. * @param v1 被乘数
  104. * @param v2 乘数
  105. * @return 两个参数的积
  106. */
  107. public static BigDecimal mul(String v1, String v2) {
  108. BigDecimal b1 = new BigDecimal(v1);
  109. BigDecimal b2 = new BigDecimal(v2);
  110. return b1.multiply(b2);
  111. }
  112. /**
  113. * 提供精确的乘法运算
  114. *
  115. * @param v1 被乘数
  116. * @param v2 乘数
  117. * @param scale 保留scale 位小数
  118. * @return 两个参数的积
  119. */
  120. public static double mul(double v1, double v2, int scale) {
  121. BigDecimal b1 = new BigDecimal(Double.toString(v1));
  122. BigDecimal b2 = new BigDecimal(Double.toString(v2));
  123. return round(b1.multiply(b2).doubleValue(), scale);
  124. }
  125. /**
  126. * 提供精确的乘法运算
  127. *
  128. * @param v1 被乘数
  129. * @param v2 乘数
  130. * @param scale 保留scale 位小数
  131. * @return 两个参数的积
  132. */
  133. public static String mul(String v1, String v2, int scale) {
  134. if (scale < 0) {
  135. throw new IllegalArgumentException("The scale must be a positive integer or zero");
  136. }
  137. BigDecimal b1 = new BigDecimal(v1);
  138. BigDecimal b2 = new BigDecimal(v2);
  139. return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  140. }
  141. /**
  142. * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到 小数点以后10位,以后的数字四舍五入
  143. *
  144. * @param v1 被除数
  145. * @param v2 除数
  146. * @return 两个参数的商
  147. */
  148. public static double div(double v1, double v2) {
  149. return div(v1, v2, DEF_DIV_SCALE);
  150. }
  151. /**
  152. * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指 定精度,以后的数字四舍五入
  153. *
  154. * @param v1 被除数
  155. * @param v2 除数
  156. * @param scale 表示表示需要精确到小数点以后几位。
  157. * @return 两个参数的商
  158. */
  159. public static double div(double v1, double v2, int scale) {
  160. if (scale < 0) {
  161. throw new IllegalArgumentException("The scale must be a positive integer or zero");
  162. }
  163. BigDecimal b1 = new BigDecimal(Double.toString(v1));
  164. BigDecimal b2 = new BigDecimal(Double.toString(v2));
  165. return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
  166. }
  167. /**
  168. * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指 定精度,以后的数字四舍五入
  169. *
  170. * @param v1 被除数
  171. * @param v2 除数
  172. * @param scale 表示需要精确到小数点以后几位
  173. * @return 两个参数的商
  174. */
  175. public static String div(String v1, String v2, int scale) {
  176. if (scale < 0) {
  177. throw new IllegalArgumentException("The scale must be a positive integer or zero");
  178. }
  179. BigDecimal b1 = new BigDecimal(v1);
  180. BigDecimal b2 = new BigDecimal(v1);
  181. return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
  182. }
  183. /**
  184. * 提供精确的小数位四舍五入处理
  185. *
  186. * @param v 需要四舍五入的数字
  187. * @param scale 小数点后保留几位
  188. * @return 四舍五入后的结果
  189. */
  190. public static double round(double v, int scale) {
  191. if (scale < 0) {
  192. throw new IllegalArgumentException("The scale must be a positive integer or zero");
  193. }
  194. BigDecimal b = new BigDecimal(Double.toString(v));
  195. return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
  196. }
  197. /**
  198. * 提供精确的小数位四舍五入处理
  199. *
  200. * @param v 需要四舍五入的数字
  201. * @param scale 小数点后保留几位
  202. * @return 四舍五入后的结果
  203. */
  204. public static String round(String v, int scale) {
  205. if (scale < 0) {
  206. throw new IllegalArgumentException("The scale must be a positive integer or zero");
  207. }
  208. BigDecimal b = new BigDecimal(v);
  209. return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  210. }
  211. /**
  212. * 取余数
  213. *
  214. * @param v1 被除数
  215. * @param v2 除数
  216. * @param scale 小数点后保留几位
  217. * @return 余数
  218. */
  219. public static String remainder(String v1, String v2, int scale) {
  220. if (scale < 0) {
  221. throw new IllegalArgumentException("The scale must be a positive integer or zero");
  222. }
  223. BigDecimal b1 = new BigDecimal(v1);
  224. BigDecimal b2 = new BigDecimal(v2);
  225. return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  226. }
  227. /**
  228. * 取余数 BigDecimal
  229. *
  230. * @param v1 被除数
  231. * @param v2 除数
  232. * @param scale 小数点后保留几位
  233. * @return 余数
  234. */
  235. public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
  236. if (scale < 0) {
  237. throw new IllegalArgumentException("The scale must be a positive integer or zero");
  238. }
  239. return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
  240. }
  241. /**
  242. * 比较大小
  243. *
  244. * @param v1 被比较数
  245. * @param v2 比较数
  246. * @return 如果v1 大于v2 则 返回true 否则false
  247. */
  248. public static boolean compare(String v1, String v2) {
  249. BigDecimal b1 = new BigDecimal(v1);
  250. BigDecimal b2 = new BigDecimal(v2);
  251. int bj = b1.compareTo(b2);
  252. boolean res;
  253. if (bj > 0)
  254. res = true;
  255. else
  256. res = false;
  257. return res;
  258. }
  259. }