People expect computer programs to be accurate and precise when calculating numbers, and especially programs that perform monetary calculations and as a Java developer,\u00a0sooner or later you will need to deal with monetary calculations.<\/p>\n
You may be tempted to use the primitive types of\u00a0 You have 1.55 $ and you bought a candy worth 35 \u00a2. How much is left with you?<\/p>\n Let’s do the calculation in Java.<\/p>\n If you said 1.20 $, you are in for a surprise. The output is:<\/p>\n Let us look at another example, this time using The output is:<\/p>\n We again have some unexpected numbers. A simple multiplication “10.00 X .0825” is not giving us what we expected “0.825”.<\/p>\n So what’s the problem? Why can\u2019t Java perform such simple calculations? The problem is not with Java but how floating point is defined in the IEEE 754<\/a> standard based on which Java implements Without going into more details of binary floating point arithmetic, let\u2019s find out how to perform monetary calculations accurately in Java. A solution is to do everything using integral types ( The During addition and subtraction operations, To perform the arithmetic calculations, Let\u2019s now perform some In the example above, we created two The output is:<\/p>\n As we can see the addition, subtraction, and multiplication in lines 4-6 were done as expected but the division in line 7 resulted in an exception. This happened because what we have is a non-terminating decimal expansion “2.5\/3.5 = 0.7142857142857. . . . .”. As mentioned earlier, for division To avoid such exceptions, always set a resulting scale and a rounding mode during division by using the overloaded Note<\/strong>: To display Now, the question is- Which rounding mode should I use for monetary calculations? The answer is, there is “no specific” mode. It depends on the application requirements and any legal contracts that your application must conform with. For example, it is common to use Let\u2019s now write some code to perform some monetary calculations using <\/p>\n In the example above, we first wrote a <\/p>\n The output is:<\/p>\n In the output above, observe how While float and double are natural choices for scientific, statistical and engineering calculations, I’ve committed the source code for this post to GitHub. It is a Maven project which you can download and build. If you wish to learn more about the Spring Framework, I have a free introduction to the Spring tutorial. You can sign up for this tutorial in the section below.<\/p>\n\r\n\t People expect computer programs to be accurate and precise when calculating numbers, and especially programs that perform monetary calculations and as a Java developer,\u00a0sooner or later you will need to deal with monetary calculations. You may be tempted to use the primitive types of\u00a0float\u00a0or\u00a0double for non-integer numbers. Both of these types support numbers with decimals. […]Continue reading<\/a><\/p>\n","protected":false},"author":1,"featured_media":4592,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_lmt_disableupdate":"","_lmt_disable":"","_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"Monetary Calculation Pitfalls in Java http:\/\/wp.me\/p5BZrZ-fQ #java","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[20],"tags":[84,27],"class_list":["post-982","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-bigdecimal","tag-java"],"jetpack_publicize_connections":[],"aioseo_notices":[],"modified_by":"Simanta","jetpack_sharing_enabled":true,"jetpack_featured_media_url":"https:\/\/springframework.guru\/wp-content\/uploads\/2015\/03\/Banner560x292_07web.jpg","jetpack_shortlink":"https:\/\/wp.me\/p5BZrZ-fQ","_links":{"self":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/982"}],"collection":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/comments?post=982"}],"version-history":[{"count":10,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/982\/revisions"}],"predecessor-version":[{"id":5616,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/982\/revisions\/5616"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media\/4592"}],"wp:attachment":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media?parent=982"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/categories?post=982"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/tags?post=982"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}float<\/code>\u00a0or\u00a0double<\/code> for non-integer numbers. Both of these types support numbers with decimals. As we will see below, there are some significant pitfalls in using these primitive types for monetary calculations.<\/p>\nMonetary Calculations: Bad Examples<\/h2>\n
. . .\r\nfloat pocketMoney=1.55f;\r\nfloat price=.35f;\r\nSystem.out.println(pocketMoney - price);\r\n. . .\r\n<\/pre>\n
1.1999999<\/pre>\n
double<\/code>. A product is priced 10 $. What is the price after adding 8.25 % tax to it?<\/p>\n. . .\r\ndouble amount = 10.00;\r\ndouble tax = .0825;\r\ndouble taxAmount = amount * tax;\r\ndouble amountAfterTax = amount + taxAmount;\r\nSystem.out.println(\"Tax: \"+ taxAmount);\r\nSystem.out.println(\"Amount after tax: \" + amountAfterTax);\r\n. . .\r\n<\/pre>\n
Tax: 0.8250000000000001\r\nAmount after tax: 10.825\r\n<\/pre>\n
float<\/code> and double<\/code>. Floating points are designed to provide accurate approximations (but not exact results<\/strong>) quickly and it is impossible to exactly represent 0.1 (or any other negative power of ten) as a Java float<\/code> or double<\/code>.<\/p>\nint<\/code> and long<\/code>) and I have met several programmers advocating it. But then you will need to remember that “325” in your program is really “3.25” dollar. Also, how will you do percent calculations rounding to the nearest cent? This is when you should turn to the BigDecimal<\/a> class.<\/p>\nMonetary Calculations Using BigDecimal<\/h2>\n
BigDecimal<\/code> class is a part of the java.math<\/code> package. For a decimal number, BigDecimal<\/code> internally stores the unscaled value in a BigInteger<\/code> and the decimal scale (digits to the right of the decimal point) in an integer<\/code>. So, the internally used BigInteger<\/code> allows BigDecimal<\/code> to represent any number, however big it is (only limited to physical memory) and the integer allows accurate handling of the decimal scale.<\/p>\nBigDecimal<\/code> expands the number with the smallest scale before performing the operation. This guarantees that the sum or difference is exact to the last digit. During multiplication, BigDecimal<\/code> computes the sum of the numbers scale and based on it expands its decimal scale.\u00a0For division, BigDecimal<\/code> expects that the result can be represented with a scale that is the difference between the scale of the dividend and divisor.<\/p>\nBigDecimal<\/code> provides the add()<\/code>, subtract()<\/code>, multiply()<\/code>, and divide()<\/code> methods. Before we use these methods, we need to represent the numbers as BigDecimal<\/code> objects. The BigDecimal<\/code> class contains 16 overloaded constructors but the one that you will use to represent a monetary value is BigDecimal(String val)<\/code>. This is important because if you mistakenly use the one that accepts double<\/code>, you will face same issues as you do while using float<\/code> and double<\/code>. This happens because the float<\/code> or double<\/code> parameter value will undergo loss of precision before you pass them to the constructor. On the other hand, when you use the String<\/code> constructor, BigDecimal<\/code> will represent exactly the number you pass to it.<\/p>\nBigDecimal<\/code> calculations.<\/p>\n. . .\r\nBigDecimal num1 = new BigDecimal(\"2.5\");\r\nBigDecimal num2 = new BigDecimal(\"3.5\");\r\nSystem.out.println(\"BigDecimal Addition: \"+ num1.add(num2));\r\nSystem.out.println(\"BigDecimal Subtraction: \"+ num1.subtract(num2));\r\nSystem.out.println(\"BigDecimal Multiplication: \"+ num1.multiply(num2));\r\nSystem.out.println(\"BigDecimal Division: \"+ num1.divide(num2));\r\n. . .\r\n<\/pre>\n
BigDecimal<\/code> numbers and called the the add()<\/code>, subtract()<\/code>, multiply()<\/code>, and divide()<\/code> methods to perform arithmetic calculations.<\/p>\nBigDecimal Addition: 6.0\r\nBigDecimal Subtraction: -1.0\r\nBigDecimal Multiplication: 8.75\r\nException in thread \"main\" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.\r\n\tat java.math.BigDecimal.divide(BigDecimal.java:1690)\r\n\tat prototype.CloneExample.main(CloneExample.java:24)\r\n<\/pre>\n
BigDecimal<\/code> expects that the result can be represented with a scale that is the difference between the scale of the dividend and divisor. Else, the JavaDoc says “. . .if the exact quotient cannot be represented (because it has a non-terminating decimal expansion) an ArithmeticException is thrown”<\/em>– and hence the exception thrown in line 7.<\/p>\ndivide(BigDecimal divisor, int scale, RoundingMode roundingMode)<\/code> method. In this method, the first parameter is the BigDecimal<\/code> divisor. The second parameter specifies the decimal scale and the third an enumeration value of the RoundingMode<\/code> enum. This enum, introduced in Java SE 6, provides eight different types of rounding modes whose descriptions with examples are available here<\/a>.<\/p>\nBigDecimal<\/code> itself have integer fields to represent rounding modes, but they are now obsolete. Ensure that you instead use the RoundingMode<\/code> enum for rounding modes in calculations.<\/p>\nBigDecimal<\/code> numbers, you can set the scale and rounding mode with the BigDecimal.setScale(scale, roundingMode)<\/code> method.<\/p>\nRoundingMode.HALF_UP<\/code> for tax calculations. If you are selling a product and want to round in favor of the customer, use RoundingMode.CEILING<\/code>. If you are not sure, go for RoundingMode.HALF_EVEN<\/code>. This rounding mode, also known as “Banker’s rounding”<\/em>, when applied repeatedly over a sequence of calculations statistically minimizes cumulative error.<\/p>\nBigDecimal<\/code>.<\/p>\npackage guru.springframework.blog.monetarycalculations;\r\n\r\nimport java.math.BigDecimal;\r\nimport java.math.RoundingMode;\r\n\r\n\r\npublic class BigDecimalCalc {\r\n\r\n public void calculate(String param1, String param2){\r\n System.out.println(\"--------------------calculate-----------------------\");\r\n BigDecimal num1=new BigDecimal(param1);\r\n BigDecimal num2=new BigDecimal(param2);\r\n System.out.println(\"num1: \"+num1+\" num2: \"+ num2);\r\n System.out.println(\"BigDecimal Addition: \"+num1.add(num2));\r\n System.out.println(\"BigDecimal Subtraction: \" + num1.subtract(num2));\r\n System.out.println(\"BigDecimal Multiplication: \"+num1.multiply(num2));\r\n }\r\n\r\n\r\n public void divideWithScaleRounding(String param1, String param2){\r\n System.out.println(\"--------------------divisionWithScaleRounding-----------------------\");\r\n\r\n \/*Setting scale and rounding mode for division using overloaded divide(BigDecimal divisor, int scale, RoundingMode roundingMode) *\/\r\n BigDecimal num1=new BigDecimal(param1);\r\n BigDecimal num2=new BigDecimal(param2);\r\n System.out.println(\"num1: \"+num1+\" num2: \"+ num2);\r\n System.out.println(\"BigDecimal Division with overloaded divide(): \" + num1.divide(num2, 4, RoundingMode.HALF_EVEN));\r\n }\r\n\r\n public void calculateTax(String amount, String tax){\r\n System.out.println(\"--------------------calculateTax-----------------------\");\r\n BigDecimal bdAmount = new BigDecimal(amount);\r\n BigDecimal bdTax = new BigDecimal(tax);\r\n BigDecimal taxAmount = bdAmount.multiply(bdTax);\r\n \/*Setting scale and rounding mode using setScale() *\/\r\n taxAmount = taxAmount.setScale(2, RoundingMode.HALF_UP);\r\n BigDecimal finalAmount = bdAmount.add(taxAmount);\r\n finalAmount = finalAmount.setScale(2, RoundingMode.HALF_UP);\r\n\r\n System.out.println(\"Amount : \" + bdAmount);\r\n System.out.println(\"Tax : \" + taxAmount);\r\n System.out.println(\"Amount after tax: \" + finalAmount);\r\n\r\n }\r\n}\r\n<\/pre>\ncalculate()<\/code> method that accepts two String<\/code> parameters. In lines 13-14 we converted them into BigDecimal<\/code>. In lines 16-18 we performed addition, subtraction, and multiplication operations on the numbers. Next, we wrote a divideWithScaleRounding()<\/code> method that also accepts two String<\/code> parameters that we converted to BigDecimal<\/code> in line 26-27. In line 29, we performed a division with a scale 4 and a rounding mode, RoundingMode.HALF_EVEN<\/code>. Then, we wrote a calculateTax()<\/code> method that accepts a monetary amount and a tax as String<\/code> objects. After converting the parameters to BigDecimal<\/code>, we calculated the tax amount in line 36. To display the tax amount with a scale 2 and a rounding mode RoundingMode.HALF_UP<\/code>, we called the setScale()<\/code> method in line 38. Similarly, we calculated the final amount and set its scale and rounding mode in lines 39-40. To test our example, let’s write this unit test.<\/p>\npackage guru.springframework.blog.monetarycalculations;\r\n\r\nimport org.junit.Test;\r\n\r\n\r\npublic class BigDecimalCalcTest {\r\n\r\n @Test\r\n public void testCalculate() throws Exception {\r\n new BigDecimalCalc().calculate(\"4.0\", \"2.0\");\r\n }\r\n\r\n @Test\r\n public void testDivideWithScaleRounding() throws Exception {\r\n new BigDecimalCalc().divideWithScaleRounding(\"2.5\", \"3.5\");\r\n }\r\n\r\n @Test\r\n public void testCalculateTax() throws Exception {\r\n new BigDecimalCalc().calculateTax(\"10.00\", \".0825\");\r\n }\r\n}\r\n<\/pre>\n . ____ _ __ _ _\r\n \/\\\\ \/ ___'_ __ _ _(_)_ __ __ _ \\ \\ \\ \\\r\n( ( )\\___ | '_ | '_| | '_ \\\/ _` | \\ \\ \\ \\\r\n \\\\\/ ___)| |_)| | | | | || (_| | ) ) ) )\r\n ' |____| .__|_| |_|_| |_\\__, | \/ \/ \/ \/\r\n =========|_|==============|___\/=\/_\/_\/_\/\r\n :: Spring Boot :: (v1.2.3.RELEASE)\r\n\r\nRunning guru.springframework.blog.monetarycalculations.BigDecimalCalcTest\r\n--------------------divisionWithScaleRounding-----------------------\r\nnum1: 2.5 num2: 3.5\r\nBigDecimal Division with overloaded divide(): 0.7143\r\n--------------------calculate-----------------------\r\nnum1: 4.0 num2: 2.0\r\nBigDecimal Addition: 6.0\r\nBigDecimal Subtraction: 2.0\r\nBigDecimal Multiplication: 8.00\r\n--------------------calculateTax-----------------------\r\nAmount : 10.00\r\nTax : 0.83\r\nAmount after tax: 10.83\r\nTests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.011 sec - in guru.springframework.blog.monetarycalculations.BigDecimalCalcTest\r\n<\/pre>\n
BigDecimal<\/code> performed the division and displayed monetary amounts with the specified scale and rounding mode. Using this example, go ahead and experiment with different sets of monetary values, scales, and rounding modes.<\/p>\nSummary<\/h2>\n
BigDecimal<\/code> is the ideal choice when it comes to monetary calculations. But, the precision and accuracy of BigDecimal<\/code> comes with a price- and it is performance. However, if we require completely accurate monetary calculations, sacrifice of some performance is acceptable.
\nOn an ending note, keep an eye on JSR 354: Money and Currency API<\/a>, which is planned to be included in Java 9. A part of this API is designed to support complex monetary calculation rules including calculation and display precisions. It will\u00a0be interesting to see if this API could change how we count our money in future.<\/p>\nGet The\u00a0Code<\/h2>\n
Source Code<\/h3><\/div>\r\n\t\t
<\/h1>\n","protected":false},"excerpt":{"rendered":"