- values are sometimes not equal (although you would like them to be):

// yes: -1.2 is not equal to -1.20 assertThat(new BigDecimal("-1.2").equals(new BigDecimal("-1.20")), is(false));

maybe this seems harmless but once your test will start to fail because the actual and expected domain object (using BigDecimal) are not equal although they are, you will just ask your self: why do we have to go trough this?

Also have you ever been paring with somebody on an interview, where the candidate told you that we should use BigDecimal for this interest rate calculation, but in the end you both decided not to do it - as the interview is not long enough - really BigDecimal adds aditional 10 to 30 minutes to inteview excercise as you have to deal with the equals method - and THIS is the STANDARD!!!

- equals is bad, but hashCode is even worse

// yes: hashCodes for -1.2 and -1.20 are not the same as well assertThat(new BigDecimal("-1.2").hashCode(), is(not(new BigDecimal("-1.20").hashCode())));

but why would that even matter? Well, if you ever decide to make BigDecimal key for a HashMap, than a situation might occur where you won't find any value for your number, as their hashCode won't match.

- the ways how to create BigDecimal are not unified at all (depending on your originating value there are few different ways how you create it)

new BigDecimal("-1.20"); // from string BigDecimal.valueOf(-120L, 2); // from long new BigDecimal(BigInteger.valueOf(-120L), 2); // from BigInteger // you should not create BigDecimal from float or double as you might get really weird value (because of transition from binary to decimal form)

I assumed that this is going to be fixed as this problems were present for many years, but it seems this is the design we'll have to live with.

This is why I decided to create a rewrite of BigDecimal called Decimal which you can find on this page (currently I'm finalizing the implementation):

https://github.com/MatejTymes/JavaFixes

It provides few advantages over BigDecimal

- unified creation using two possible factory methods (one more readable decimal(...), one shorter d(...))
- fixed equals
- fixed hashCode:

// equals now works assertThat(decimal("-1.2").equals(decimal("-1.200")), is(true)); assertThat(d("-1.2").equals(d("-1.200")), is(true)); // and surprisingly hashCode as well assertThat(d("-1.2").hashCode(), is(d("-1.20").hashCode()));

- also the creation approach is always the same

decimal("-1.20"); // from string decimal(-120L, 2); // from long decimal(BigInteger.valueOf(-120L), 2); // from BigInteger // you are not able to create Decimal from float or double but have to transform them into string first - otherwise you might get surprising values

- you can use underscores in the numbers to make them more readable

Decimal value = d("-125_550_00.00"); // using underscores as you can use in java numbers

The Decimal is an abstract class currently extended by two implementations: LongDecimal - if value can be backed by long and HugeDecimal - backed by BigInteger (for all other numbers). You can't address them directly, but the library handles the transition between these types seamlessly while you're calling arithmetic operations.

And that's it. Please let me know if you can think of any other improvements, or just what you feel about this. I would be happy to hear your thoughts.

Hi Matej. Interesting stuff. It also reminds me of one pattern. When BigDecimal is used to represent money (which is a common case I guess), it's a nice idea to wrap it into a Money class (https://martinfowler.com/eaaCatalog/money.html) to remove the duplication around the code base, and indeed to get nice equals, hashCode, and factory methods. Yours approach covers more ground, though :) Enjoy the weekend!

ReplyDelete