Shulou(Shulou.com)06/02 Report--

This article mainly introduces "how to use the BigDecimal class of Java". In the daily operation, I believe that many people have doubts about how to use the BigDecimal class of Java. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts about "how to use the BigDecimal class of Java". Next, please follow the editor to study!

What will we see if we compile and run the following program?

Public class Test {public static void main (String args []) {System.out.println (0.05mm 0.01); System.out.println (1.00.42); System.out.println (4.015mm 100); System.out.println (123.3 Universe 100);}}

You read it right! The result is indeed:

0.0600000000000000050.5800000000000001401.499999999999941.2329999999999999

The simple floating point types float and double in Java cannot operate. This problem exists not only in Java, but also in many other programming languages. In most cases, the results of the calculation are accurate, but a few more attempts (you can do a loop) can make an error similar to the one above. Now I finally understand why there is a BCD code.

This problem is quite serious. If you have 9.999999999999 yuan, your computer will not think that you can buy goods worth 10 yuan.

Special currency types are provided in some programming languages to handle this situation, but Java does not. Now let's see how to solve this problem.

Round off

Our response is to round it up. The round method in the Math class cannot be set to retain a few decimal places, we can only do this (keep two places):

Public double round (double value) {return Math.round (value*100) / 100.0;}

Unfortunately, the above code doesn't work properly. Passing 4.015 to this method will return 4.01 instead of 4.02, as we saw above.

4.015 100000 401.49999999999994

So if we want to do accurate rounding, we can't do any operations with simple types.

Java.text.DecimalFormat does not solve this problem either:

System.out.println (new java.text.DecimalFormat ("0.00") .format (4.025))

The output is 4.02

BigDecimal

This principle is also mentioned in the book "Effective Java". Float and double can only be used for scientific or engineering calculations, and we should use java.math.BigDecimal in business calculations. BigDecimal has a total of four constructors, we do not care about the two constructed with BigInteger, then there are two, they are:

BigDecimal (doubleval) Translates a double into a BigDecimal.BigDecimal (String val) Translates the String representation of a BigDecimal into a BigDecimal.

The brief description of the API above is quite clear, and in general, the above one is easier to use. We may use it without even thinking about it. What's the problem? When something goes wrong, I find that there is a paragraph in the detailed description of which construction method above:

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 .10000000000000055511151231257827021181583404541015625. 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 nonwithstanding.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.

It turns out that if we need accurate calculation, we must use String to construct BigDecimal! The example in "Effective Java" uses String to construct BigDecimal, but the book does not emphasize this.

Solution

Now we can solve this problem, the principle is to use BigDecimal and be sure to use String to construct.

But imagine that if we want to do an addition operation, we need to first convert two floating-point numbers to String, then construct a BigDecimal, in which one calls the add method, passes in the other as a parameter, and then converts the result of the operation (BigDecimal) into a floating-point number. Can you stand such a tedious process? Next we provide a utility class Arith to simplify the operation. It provides the following static methods, including addition, subtraction, multiplication and division, and rounding:

Public static double add (double v1 magnificent double v2) public static double sub (double v1 magnificent double v2) public static double mul (double v1 magnificent double v2) public static double div (double v1 magnificent double v2) public static double div (double v1 magnificent double scale) public static double round (double vMagint scale)

Attached record

Source file Arith.java:

Import java.math.BigDecimal; / * because Java's simple type does not accurately operate on floating-point numbers, this utility class provides precise floating-point operations, including addition, subtraction, multiplication and division, and rounding. * / public class Arith {/ / default division precision private static final int DEF_DIV_SCALE = 10; / / this class cannot instantiate private Arith () {} / * * to provide precise addition operations. * @ param v1 is added * @ param v2 plus * @ return the sum of two parameters * / public static double add (double v1) {BigDecimal b1 = new BigDecimal (Double.toString (v1)); BigDecimal b2 = new BigDecimal (Double.toString (v2)); return b1.add (b2). DoubleValue ();} / * * provides precise subtraction. * @ param v1 is subtracted * @ param v2 minus * @ return the difference between the two parameters * / public static double sub (double v1 minus double v2) {BigDecimal b1 = new BigDecimal (Double.toString (v1)); BigDecimal b2 = new BigDecimal (Double.toString (v2)); return b1.subtract (b2). DoubleValue ();} / * * provides accurate multiplication. * @ param v1 multiplier * @ param v2 multiplier * @ return the product of two parameters * / public static double mul (double v1 and double v2) {BigDecimal b1 = new BigDecimal (Double.toString (v1)); BigDecimal b2 = new BigDecimal (Double.toString (v2)); return b1.multiply (b2). DoubleValue () } / * provides a (relatively) precise division operation, which is accurate to 10 digits after the * decimal point when inexhaustible division occurs, and subsequent numbers are rounded. The quotient of * @ param v1 divisor * @ param v2 divisor * @ return is * / public static double div (double v1 and double v2) {return div (v1 and v2);} / * * provides (relative) precise division operations. When an inexhaustible situation occurs, the precision is determined by the scale parameter, and the subsequent numbers are rounded. The * @ param v1 divisor * @ param v2 divisor * @ param scale indicates that it needs to be accurate to a few places after the decimal point. The quotient of the two parameters * @ return * / public static double div (double v1 if v2 scale) {if (scale=.5, it is ROUND_UP; otherwise, ROUND_DOWN.

ROUND_UNNECESSARY. Static variable in class java.math.BigDecimal: this "pseudo-rounding mode" actually requires an exact result of the operation, so it does not need to be rounded.

ROUND_UP. Static variable in class java.math.BigDecimal: always increments the number before a non-zero discarding decimal (that is, truncation).

At this point, the study on "how to use the BigDecimal class of Java" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.