Class Money


public class Money extends AbstractAmount
Represents a monetary amount by combining a BigDecimal and a Currency. Please know that the scale of the amount is always equal to the amount of currency digits.Therefore the following rules apply:
used values result
BigDecimal Currency.getDigits() Money.getAmount() as BigDecimal
new BigDecimal(1.000) 0 1
new BigDecimal(1.000) 3 1.000
BigDecimal.ZERO 2 0.00
BigDecimal.valueOf(-1.34) 3 -1.340
BigDecimal.valueOf(1.234) 1 1.2 since we simply cut off the extra digits

This class provides common operations like add(Money), subtract(Money) and split(List).

A Money in the smallest amount (example 0.01 EUR) can not be split in smaller amounts. Splitting this amount in two will return {0.01 EUR, 0.00 EUR}.

Last but not least there are a number of tool methods to ease working with this class: zero(Currency), valueOf(Currency, String...), sum(Collection), sortAscending(List) and getPercentages(Money...) to name a few.

  • Field Details

  • Constructor Details

    • Money

      public Money(BigDecimal amount, Currency currency)
      Creates a Money object. A new BigDecimal object is used internally, based on Currency.getDigits().

      amount and this.getAmount() are maybe not equal (because of the different scale of the BigDecimal) BUT new Money(BigDecimal.ONE, curr) and new Money(new BigDecimal("1.000"), curr) are equal with each other!

      Parameters:
      amount - the value or amount of the money
      currency - the amount of the money in the hybris Currency pojo
      Throws:
      ArithmeticException - if the amount must be rounded because the Currency.getDigits() does not provide enough digits.
    • Money

      public Money(Currency currency)
      Creates zero money of the given Currency.
      Parameters:
      currency -
    • Money

      public Money(long amountInSmallestPieces, Currency currency)
      Creates a new money from a given amount of smallest pieces and a currency.
    • Money

      public Money(String amount, Currency currency)
      Creates a new money from String and currency.
  • Method Details

    • valueOf

      public static List<Money> valueOf(Currency curr, String... amounts)
      Creates a list of money objects for a specific currency and any number of String values.
    • valueOf

      public static List<Money> valueOf(Currency curr, long... amounts)
      Creates a list of money objects for a specific currency and any number of long values.
    • valueOf

      public static List<Money> valueOf(Currency curr, BigDecimal... amounts)
      Creates a list of money objects for a specific currency and any number of BigDecimal values.
    • zero

      public static Money zero(Currency curr)
      Shortcut to obtain commonly used zero money instances. Since they are cached this methods should be preferred to Money(Currency).
    • getCurrency

      public Currency getCurrency()
      Returns the currency of this money.
    • getAmount

      public BigDecimal getAmount()
      The monetary amount. The amount scale is equal to the currency digits!
    • assertCurreniesAreEqual

      public void assertCurreniesAreEqual(Currency curr)
      Checks if the current Currency is equal to given one.
      Throws:
      CurrenciesAreNotEqualException - if the currencies are not equal.
    • assertCurreniesAreEqual

      public void assertCurreniesAreEqual(Money other)
      Checks if the current Currency is equal to given one.
      Throws:
      CurrenciesAreNotEqualException - if the currencies are not equal.
    • add

      public Money add(Money money)
      Add to the current Money amount the given Money amount. The result is a new Money object with the sum of both amounts and in the same currency.
      Parameters:
      money - this will be added to the current money amount
      Returns:
      a new object with the sum
      Throws:
      CurrenciesAreNotEqualException - if getCurrency() is different in the given objects
    • subtract

      public Money subtract(Money money)
      Subtracts from current Money amount the given Money amount. The result is a new Money object with the difference of both amounts and in the same currency.
      Parameters:
      money - this will be subtracted to the current money amount
      Returns:
      a new object with the difference
      Throws:
      CurrenciesAreNotEqualException - if getCurrency() is different in the given objects
    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object
      Returns:
      currency.hashCode + amount.hashCode
    • equals

      public boolean equals(Object obj)
      Returns true if the given parameter is also an instanceof money and the current currency is equal to the currency of the given money and the current amount is comparedTo == 0 to the given money amount. (this is not BigDecimal.equals(BigDecimal), the check is BigDecimal.compareTo(BigDecimal))
      Overrides:
      equals in class Object
    • toString

      public String toString()
      Returns the amount of the value formatted with the Currency.getDigits() and the currency isocode. Example: "1.20 EUR"
      Overrides:
      toString in class AbstractAmount
      Returns:
      {0.xx} {currency.toString};
      xx.lenght == currency.digits
    • split

      public List<Money> split(Percentage... percentages)
      Same as split(List) but because of the variable parameter list the sum must not be exactly 100%. If less the missing Percentage value will be added. This means, the size of the resulting list is equal to the given percentage list if the sum of them is exactly 100% or the size of the resulting list is one more if the given percentage list is less than 100%. Anyway a CalculationException is thrown if the sum is greater than 100%.
      Parameters:
      percentages - the variable list of percentages
      Returns:
      a List of Money objects which are summed up the same amount of this current Money object.
    • split

      public List<Money> split(List<Percentage> percentages)
      Splits the current Money into a list of new Money objects, based on the given list of Percentage objects. The sum of the Percentages must be equal to 100% or a CalculationException is thrown. The size of the returned money list is equal to the size of the given percentage list. The sum of the returned money list is equal to the given amount of money. A money can only be split into the smallest possible amount of this money which depends on the currency. If a small amount of money can not be split anymore this amount is added to the last entry in the returned list.

      Example: splitting 0.01 EURO into half results in [0.00EUR , 0.01EUR]

      Parameters:
      percentages - the list of Percentage in which the current money should be split into.
      Returns:
      a List of Money objects which are summed up the same amount of this current Money object.
      Throws:
      AmountException - if the sum of the percentages is not 100%
      IllegalArgumentException - if the percent list is null or empty
    • checkPercentages

      protected BigDecimal checkPercentages(List<Percentage> percentages)
    • sortByMoneyAscending

      public static <T> List<T> sortByMoneyAscending(Map<T,Money> moneyMap)
    • sortByMoney

      protected static <T> List<T> sortByMoney(Map<T,Money> moneyMap, Comparator<Map.Entry<?,Money>> comp)
    • sortByMoneyDescending

      public static <T> List<T> sortByMoneyDescending(Map<T,Money> moneyMap)
    • sortAscending

      public static void sortAscending(List<Money> elements)
    • sortDescending

      public static void sortDescending(List<Money> elements)
    • sum

      public static final <T> Money sum(Collection<T> elements, Money.MoneyExtractor<T> extractor)
    • sum

      public static final Money sum(Money... money)
    • sum

      public static final Money sum(Collection<Money> elements)
    • sumUnscaled

      protected static final <T> Money sumUnscaled(Collection<T> elements, Money.MoneyExtractor<T> extractor)
    • sumUnscaled

      protected static final long sumUnscaled(Collection<Money> elements)
    • getPercentages

      public static List<Percentage> getPercentages(Money... moneys)
      Calculates a list of Percentage objects reflecting the distribution of money within the given money list. Please note that the scale of these percentages is zero.
      See Also:
    • getPercentages

      public static List<Percentage> getPercentages(int scale, Money... moneys)
      Calculates a list of Percentage objects reflecting the distribution of money within the given money list. The specified scale is defining the precision of these percentages.
      See Also:
    • getPercentages

      public static List<Percentage> getPercentages(List<Money> moneys, int scale)
      Calculates a list of Percentage objects reflecting the distribution of money within the given money list. The specified scale is defining the precision of these percentages.
      See Also:
    • getSortedPositionTable

      protected static int[] getSortedPositionTable(List<Money> moneyList)