MonetaryAmount (JSR 354 (Money and Currency API) 1.0.1 API)

All Superinterfaces:

Comparable<MonetaryAmount>, CurrencySupplier, NumberSupplier
```
public interface MonetaryAmount
extends CurrencySupplier, NumberSupplier, Comparable<MonetaryAmount>
```
Interface defining a monetary amount. The effective format representation of an amount may vary depending on the implementation used. JSR 354 explicitly supports different types of monetary amounts to be implemented and used. Reason behind is that the requirements to an implementation heavily vary for different usage scenarios. E.g. product calculations may require high precision and scale, whereas low latency order and trading systems require high calculation performance for algorithmic operations.
Each instance of an amount provides additional meta-data in form of a MonetaryContext. This context contains detailed information on the numeric capabilities, e.g. the supported precision and maximal scale, as well as the common implementation flavor. Also a MonetaryAmount provides a NumberValue, which allows easily to extract the numeric value, of the amount. And finally getFactory() provides a MonetaryAmountFactory, which allows to of instances of MonetaryAmount based on the same numeric implementation.
This JSR additionally recommends to consider the following aspects:
- Arithmetic operations should throw an ArithmeticException, if performing arithmetic operations between amounts exceeds the capabilities of the numeric representation type used. Any implicit truncating, that would lead to complete invalid and useless results, should be avoided. This recommendation does not affect format rounding, as required by the format numeric representation of a monetary amount.
- Monetary amounts should allow numbers as argument for arithmetic operations like division and multiplication. Adding or subtracting of amounts must only be possible by passing instances of MonetaryAmount.
- Nevertheless numeric truncation is also explicitly supported when calling NumberValue.numberValue(Class), whereas the exact counterpart, NumberValue.numberValueExact(Class), works similar to BigDecimal.longValueExact().
- Since implementations are recommended to be immutable, an operation should never change any format state of an instance. Given an instance, all operations are required to be fully reproducible.
- Finally the result of calling with(MonetaryOperator) must be of the same type as type on which with was called. The with method also defines additional interoperability requirements that are important to enable this invariant.
- To enable further interoperability a static method from(MonetaryAmount) is recommended to be implemented on each implementation class, that allows conversion of a MonetaryAmount to a concrete instance. E.g.a class MyMoney extends MonetaryAmount would contain the following method:
```
 public final class MyMoney implements MonetaryAmount{
   ...
   public static MyMoney from(MonetaryAmount amount)(...)
 }
 
```
Implementation specification
Implementations of this interface must be
- thread-safe
Implementations of this interface should be
- final
- serializable, hereby writing the numeric value, the MonetaryContext and a serialized CurrencyUnit.
Implementations of this interface must be
- thread-safe
- immutable
- comparable
- must implement equals/hashCode, hereby considering
  - Implementation type
  - CurrencyUnit
  - Numeric value.
  This also means that two different implementations types with the same currency and numeric value are NOT equal.
Version:

0.8.2

Author:

Anatole Tresch, Werner Keil

See Also:

with(MonetaryOperator)

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`MonetaryAmount`	`abs()` Returns a `MonetaryAmount` whose value is the absolute value of this `MonetaryAmount`, and whose scale is `this.scale()`.
`MonetaryAmount`	`add(MonetaryAmount amount)` Returns a `MonetaryAmount` whose value is `this + amount`, and whose scale is `max(this.scale(), amount.scale()`.
`MonetaryAmount`	`divide(double divisor)` Returns a `MonetaryAmount` whose value is `this / divisor`, and whose preferred scale is `this.scale() - divisor.scale()`; if the exact quotient cannot be represented an `ArithmeticException` is thrown.
`MonetaryAmount`	`divide(long divisor)` Returns a `MonetaryAmount` whose value is `this / divisor`, and whose preferred scale is `this.scale() - divisor.scale()`; if the exact quotient cannot be represented an `ArithmeticException` is thrown.
`MonetaryAmount`	`divide(Number divisor)` Returns a `MonetaryAmount` whose value is `this / divisor`, and whose preferred scale is `this.scale() - divisor.scale()`; if the exact quotient cannot be represented an `ArithmeticException` is thrown.
`MonetaryAmount[]`	`divideAndRemainder(double divisor)` Returns a two-element `MonetaryAmount` array containing the result of `divideToIntegralValue` followed by the result of `remainder` on the two operands.
`MonetaryAmount[]`	`divideAndRemainder(long divisor)` Returns a two-element `MonetaryAmount` array containing the result of `divideToIntegralValue` followed by the result of `remainder` on the two operands.
`MonetaryAmount[]`	`divideAndRemainder(Number divisor)` Returns a two-element `MonetaryAmount` array containing the result of `divideToIntegralValue` followed by the result of `remainder` on the two operands.
`MonetaryAmount`	`divideToIntegralValue(double divisor)` Returns a `MonetaryAmount` whose value is the integer part of the quotient `this / divisor` rounded down.
`MonetaryAmount`	`divideToIntegralValue(long divisor)` Returns a `MonetaryAmount` whose value is the integer part of the quotient `this / divisor` rounded down.
`MonetaryAmount`	`divideToIntegralValue(Number divisor)` Returns a `MonetaryAmount` whose value is the integer part of the quotient `this / divisor` rounded down.
`MonetaryContext`	`getContext()` Returns the `MonetaryContext` of this `MonetaryAmount`.
`MonetaryAmountFactory<? extends MonetaryAmount>`	`getFactory()` Creates a new `MonetaryAmountFactory`, returning the same implementation type Hereby this given amount is used as a template, so reusing the `CurrencyUnit`, its numeric value, the algorithmic implementation as well as the current `MonetaryContext`.
`boolean`	`isEqualTo(MonetaryAmount amount)` Compares two instances of `MonetaryAmount`, hereby ignoring non significant trailing zeroes and different numeric capabilities.
`boolean`	`isGreaterThan(MonetaryAmount amount)` Compares two instances of `MonetaryAmount`, hereby ignoring non significant trailing zeroes and different numeric capabilities.
`boolean`	`isGreaterThanOrEqualTo(MonetaryAmount amount)` Compares two instances of `MonetaryAmount`, hereby ignoring non significant trailing zeroes and different numeric capabilities.
`boolean`	`isLessThan(MonetaryAmount amount)` Compares two instances of `MonetaryAmount`, hereby ignoring non significant trailing zeroes and different numeric capabilities.
`boolean`	`isLessThanOrEqualTo(MonetaryAmount amt)` Compares two instances of `MonetaryAmount`, hereby ignoring non significant trailing zeroes and different numeric capabilities.
`default boolean`	`isNegative()` Checks if a `MonetaryAmount` is negative.
`default boolean`	`isNegativeOrZero()` Checks if a `MonetaryAmount` is negative or zero.
`default boolean`	`isPositive()` Checks if a `MonetaryAmount` is positive.
`default boolean`	`isPositiveOrZero()` Checks if a `MonetaryAmount` is positive or zero.
`default boolean`	`isZero()` Checks if an `MonetaryAmount` is zero.
`MonetaryAmount`	`multiply(double multiplicand)` Returns a `MonetaryAmount` whose value is `(this × multiplicand)`, and whose scale is `this.scale() + multiplicand.scale()`.
`MonetaryAmount`	`multiply(long multiplicand)` Returns a `MonetaryAmount` whose value is `(this × multiplicand)`, and whose scale is `this.scale() + multiplicand.scale()`.
`MonetaryAmount`	`multiply(Number multiplicand)` Returns a `MonetaryAmount` whose value is `(this × multiplicand)`, and whose scale is `this.scale() + multiplicand.scale()`.
`MonetaryAmount`	`negate()` Returns a `MonetaryAmount` whose value is `-this`, and whose scale is `this.scale()`.
`MonetaryAmount`	`plus()` Returns a `MonetaryAmount` whose value is `+this`, with rounding according to the context settings.
`default <R> R`	`query(MonetaryQuery<R> query)` Queries this monetary amount for a value.
`MonetaryAmount`	`remainder(double divisor)` Returns a `MonetaryAmount` whose value is `this % divisor`.
`MonetaryAmount`	`remainder(long divisor)` Returns a `MonetaryAmount` whose value is `this % divisor`.
`MonetaryAmount`	`remainder(Number divisor)` Returns a `MonetaryAmount` whose value is `this % divisor`.
`MonetaryAmount`	`scaleByPowerOfTen(int power)` Returns a `MonetaryAmount` whose numerical value is equal to ( `this` * 10ⁿ).
`int`	`signum()` Returns the signum function of this `MonetaryAmount`.
`MonetaryAmount`	`stripTrailingZeros()` Returns a `MonetaryAmount` which is numerically equal to this one but with any trailing zeros removed from the representation.
`MonetaryAmount`	`subtract(MonetaryAmount amount)` Returns a `MonetaryAmount` whose value is `this - amount`, and whose scale is `max(this.scale(), subtrahend.scale()`.
`default MonetaryAmount`	`with(MonetaryOperator operator)` Returns an operated object of the same type as this object with the operation made.

Methods inherited from interface javax.money.CurrencySupplier
getCurrency

Methods inherited from interface javax.money.NumberSupplier
getNumber

Methods inherited from interface java.lang.Comparable
compareTo

- Method Detail
  - getContext
```
MonetaryContext getContext()
```
    Returns the MonetaryContext of this MonetaryAmount. The MonetaryContext provides additional information about the numeric representation and the numeric capabilities. This information can be used by code to determine situations where MonetaryAmount instances must be converted to avoid implicit truncation, which can lead to invalid results.
    
    Returns:
    
    the MonetaryContext of this MonetaryAmount, never null .
  - query
```
default <R> R query(MonetaryQuery<R> query)
```
    Queries this monetary amount for a value.
    This queries this amount using the specified query strategy object.
    Implementations must ensure that no observable state is altered when this read-only method is invoked.
    
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    query - the query to invoke, not null
    
    Returns:
    
    the query result, null may be returned (defined by the query)
  - with
```
default MonetaryAmount with(MonetaryOperator operator)
```
    Returns an operated object of the same type as this object with the operation made. Hereby returning an instannce of the same type is very important to prevent uncontrolled mixup of implementations. Switching between implementations is still easily possible, e.g. by using according MonetaryAmountFactory instances:
    // converting from Money to MyMoney Money m = ...; MonetartyAmountFactory f = Monetary.queryAmountFactory(MyMoney.class); MyMoney myMoney = f.setAmount(m).of();
    This converts this monetary amount according to the rules of the specified operator. A typical operator will change the amount and leave the currency unchanged. A more complex operator might also change the currency.
    Some example code indicating how and why this method is used:
    MonetaryAmount money = money.with(amountMultipliedBy(2)); money = money.with(amountRoundedToNearestWholeUnit());
    Hereby also the method signature on the implementation type must return the concrete type, to enable a fluent API, e.g.
    public final class MyMoney implements MonetaryAmount{ ... public MyMoney with(MonetaryOperator operator){ ... } ... }
    Parameters:
    
    operator - the operator to use, not null
    
    Returns:
    
    an object of the same type with the specified conversion made, not null
  - getFactory
```
MonetaryAmountFactory<? extends MonetaryAmount> getFactory()
```
    Creates a new MonetaryAmountFactory, returning the same implementation type Hereby this given amount is used as a template, so reusing the CurrencyUnit, its numeric value, the algorithmic implementation as well as the current MonetaryContext.
    This method is used for creating a new amount result after having done calculations that are not directly mappable to the default monetary arithmetics, e.g. currency conversion.
    
    Returns:
    
    the new MonetaryAmountFactory with the given MonetaryAmount as its default values.
  - isGreaterThan
```
boolean isGreaterThan(MonetaryAmount amount)
```
    Compares two instances of MonetaryAmount, hereby ignoring non significant trailing zeroes and different numeric capabilities.
    
    Parameters:
    
    amount - the MonetaryAmount to be compared with this instance.
    
    Returns:
    
    true if amount > this.
    
    Throws:
    
    MonetaryException - if the amount's currency is not equals to the currency of this instance.
  - isGreaterThanOrEqualTo
```
boolean isGreaterThanOrEqualTo(MonetaryAmount amount)
```
    Compares two instances of MonetaryAmount, hereby ignoring non significant trailing zeroes and different numeric capabilities.
    
    Parameters:
    
    amount - the MonetaryAmount to be compared with this instance.
    
    Returns:
    
    true if amount >= this.
    
    Throws:
    
    MonetaryException - if the amount's currency is not equals to the currency of this instance.
  - isLessThan
```
boolean isLessThan(MonetaryAmount amount)
```
    Compares two instances of MonetaryAmount, hereby ignoring non significant trailing zeroes and different numeric capabilities.
    
    Parameters:
    
    amount - the MonetaryAmount to be compared with this instance.
    
    Returns:
    
    true if amount < this.
    
    Throws:
    
    MonetaryException - if the amount's currency is not equals to the currency of this instance.
  - isLessThanOrEqualTo
```
boolean isLessThanOrEqualTo(MonetaryAmount amt)
```
    Compares two instances of MonetaryAmount, hereby ignoring non significant trailing zeroes and different numeric capabilities.
    
    Parameters:
    
    amt - the MonetaryAmount to be compared with this instance.
    
    Returns:
    
    true if amount <= this.
    
    Throws:
    
    MonetaryException - if the amount's currency is not equals to the currency of this instance.
  - isEqualTo
```
boolean isEqualTo(MonetaryAmount amount)
```
    Compares two instances of MonetaryAmount, hereby ignoring non significant trailing zeroes and different numeric capabilities.
    
    Parameters:
    
    amount - the MonetaryAmount to be compared with this instance.
    
    Returns:
    
    true if amount == this.
    
    Throws:
    
    MonetaryException - if the amount's currency is not equals to the currency of this instance.
  - isNegative
```
default boolean isNegative()
```
    Checks if a MonetaryAmount is negative.
    
    Returns:
    
    true if signum() < 0.
  - isNegativeOrZero
```
default boolean isNegativeOrZero()
```
    Checks if a MonetaryAmount is negative or zero.
    
    Returns:
    
    true if signum() <= 0.
  - isPositive
```
default boolean isPositive()
```
    Checks if a MonetaryAmount is positive.
    
    Returns:
    
    true if signum() > 0.
  - isPositiveOrZero
```
default boolean isPositiveOrZero()
```
    Checks if a MonetaryAmount is positive or zero.
    
    Returns:
    
    true if signum() >= 0.
  - isZero
```
default boolean isZero()
```
    Checks if an MonetaryAmount is zero.
    
    Returns:
    
    true if signum() == 0.
  - signum
```
int signum()
```
    Returns the signum function of this MonetaryAmount.
    
    Returns:
    
    -1, 0, or 1 as the value of this MonetaryAmount is negative, zero, or positive.
  - add
```
MonetaryAmount add(MonetaryAmount amount)
```
    Returns a MonetaryAmount whose value is this + amount, and whose scale is max(this.scale(), amount.scale().
    
    Parameters:
    
    amount - value to be added to this MonetaryAmount.
    
    Returns:
    
    this + amount
    
    Throws:
    
    ArithmeticException - if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - subtract
```
MonetaryAmount subtract(MonetaryAmount amount)
```
    Returns a MonetaryAmount whose value is this - amount, and whose scale is max(this.scale(), subtrahend.scale().
    
    Parameters:
    
    amount - value to be subtracted from this MonetaryAmount.
    
    Returns:
    
    this - amount
    
    Throws:
    
    ArithmeticException - if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - multiply
```
MonetaryAmount multiply(long multiplicand)
```
    Returns a MonetaryAmount whose value is (this × multiplicand), and whose scale is this.scale() + multiplicand.scale().
    
    Parameters:
    
    multiplicand - value to be multiplied by this MonetaryAmount.
    
    Returns:
    
    this * multiplicand
    
    Throws:
    
    ArithmeticException - if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - multiply
```
MonetaryAmount multiply(double multiplicand)
```
    Returns a MonetaryAmount whose value is (this × multiplicand), and whose scale is this.scale() + multiplicand.scale(). By default the input value's scale will be rounded to accommodate the format capabilities, and no ArithmeticException is thrown if the input number's scale exceeds the capabilities.
    
    Parameters:
    
    multiplicand - value to be multiplied by this MonetaryAmount. If the multiplicand's scale exceeds the capabilities of the implementation, it may be rounded implicitly.
    
    Returns:
    
    this * multiplicand
    
    Throws:
    
    ArithmeticException - if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - multiply
```
MonetaryAmount multiply(Number multiplicand)
```
    Returns a MonetaryAmount whose value is (this × multiplicand), and whose scale is this.scale() + multiplicand.scale().
    
    Parameters:
    
    multiplicand - value to be multiplied by this MonetaryAmount. If the multiplicand's scale exceeds the capabilities of the implementation, it may be rounded implicitly.
    
    Returns:
    
    this * multiplicand
    
    Throws:
    
    ArithmeticException - if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - divide
```
MonetaryAmount divide(long divisor)
```
    Returns a MonetaryAmount whose value is this / divisor, and whose preferred scale is this.scale() - divisor.scale(); if the exact quotient cannot be represented an ArithmeticException is thrown.
    
    Parameters:
    
    divisor - value by which this MonetaryAmount is to be divided.
    
    Returns:
    
    this / divisor
    
    Throws:
    
    ArithmeticException - if the exact quotient does not have a terminating decimal expansion, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - divide
```
MonetaryAmount divide(double divisor)
```
    Returns a MonetaryAmount whose value is this / divisor, and whose preferred scale is this.scale() - divisor.scale(); if the exact quotient cannot be represented an ArithmeticException is thrown.
    
    Parameters:
    
    divisor - value by which this MonetaryAmount is to be divided.
    
    Returns:
    
    this / divisor
    
    Throws:
    
    ArithmeticException - if the exact quotient does not have a terminating decimal expansion, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - divide
```
MonetaryAmount divide(Number divisor)
```
    Returns a MonetaryAmount whose value is this / divisor, and whose preferred scale is this.scale() - divisor.scale(); if the exact quotient cannot be represented an ArithmeticException is thrown.
    
    Parameters:
    
    divisor - value by which this MonetaryAmount is to be divided.
    
    Returns:
    
    this / divisor
    
    Throws:
    
    ArithmeticException - if the exact quotient does not have a terminating decimal expansion, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - remainder
```
MonetaryAmount remainder(long divisor)
```
    Returns a MonetaryAmount whose value is this % divisor.
    
    The remainder is given by this.subtract(this.divideToIntegralValue(divisor).multiply(divisor) . Note that this is not the modulo operation (the result can be negative).
    
    Parameters:
    
    divisor - value by which this MonetaryAmount is to be divided.
    
    Returns:
    
    this % divisor.
    
    Throws:
    
    ArithmeticException - if divisor==0, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - remainder
```
MonetaryAmount remainder(double divisor)
```
    Returns a MonetaryAmount whose value is this % divisor.
    
    The remainder is given by this.subtract(this.divideToIntegralValue(divisor).multiply(divisor) . Note that this is not the modulo operation (the result can be negative).
    
    Parameters:
    
    divisor - value by which this MonetaryAmount is to be divided.
    
    Returns:
    
    this % divisor.
    
    Throws:
    
    ArithmeticException - if divisor==0, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - remainder
```
MonetaryAmount remainder(Number divisor)
```
    Returns a MonetaryAmount whose value is this % divisor.
    
    The remainder is given by this.subtract(this.divideToIntegralValue(divisor).multiply(divisor) . Note that this is not the modulo operation (the result can be negative).
    
    Parameters:
    
    divisor - value by which this MonetaryAmount is to be divided.
    
    Returns:
    
    this % divisor.
    
    Throws:
    
    ArithmeticException - if divisor==0, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - divideAndRemainder
```
MonetaryAmount[] divideAndRemainder(long divisor)
```
    Returns a two-element MonetaryAmount array containing the result of divideToIntegralValue followed by the result of remainder on the two operands.
    
    Note that if both the integer quotient and remainder are needed, this method is faster than using the divideToIntegralValue and remainder methods separately because the division need only be carried out once.
    
    Parameters:
    
    divisor - value by which this MonetaryAmount is to be divided, and the remainder computed.
    
    Returns:
    
    a two element MonetaryAmount array: the quotient (the result of divideToIntegralValue) is the initial element and the remainder is the final element.
    
    Throws:
    
    ArithmeticException - if divisor==0, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
    
    See Also:
    
    divideToIntegralValue(long), remainder(long)
  - divideAndRemainder
```
MonetaryAmount[] divideAndRemainder(double divisor)
```
    Returns a two-element MonetaryAmount array containing the result of divideToIntegralValue followed by the result of remainder on the two operands.
    
    Note that if both the integer quotient and remainder are needed, this method is faster than using the divideToIntegralValue and remainder methods separately because the division need only be carried out once.
    
    Parameters:
    
    divisor - value by which this MonetaryAmount is to be divided, and the remainder computed.
    
    Returns:
    
    a two element MonetaryAmount array: the quotient (the result of divideToIntegralValue) is the initial element and the remainder is the final element.
    
    Throws:
    
    ArithmeticException - if divisor==0, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
    
    See Also:
    
    divideToIntegralValue(double), remainder(double)
  - divideAndRemainder
```
MonetaryAmount[] divideAndRemainder(Number divisor)
```
    Returns a two-element MonetaryAmount array containing the result of divideToIntegralValue followed by the result of remainder on the two operands.
    
    Note that if both the integer quotient and remainder are needed, this method is faster than using the divideToIntegralValue and remainder methods separately because the division need only be carried out once.
    
    Parameters:
    
    divisor - value by which this MonetaryAmount is to be divided, and the remainder computed.
    
    Returns:
    
    a two element MonetaryAmount array: the quotient (the result of divideToIntegralValue) is the initial element and the remainder is the final element.
    
    Throws:
    
    ArithmeticException - if divisor==0, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
    
    See Also:
    
    divideToIntegralValue(Number), remainder(Number)
  - divideToIntegralValue
```
MonetaryAmount divideToIntegralValue(long divisor)
```
    Returns a MonetaryAmount whose value is the integer part of the quotient this / divisor rounded down. The preferred scale of the result is this.scale() - divisor.scale().
    
    Parameters:
    
    divisor - value by which this BigDecimal is to be divided.
    
    Returns:
    
    The integer part of this / divisor.
    
    Throws:
    
    ArithmeticException - if divisor==0
    
    See Also:
    
    BigDecimal.divideToIntegralValue(java.math.BigDecimal)
  - divideToIntegralValue
```
MonetaryAmount divideToIntegralValue(double divisor)
```
    Returns a MonetaryAmount whose value is the integer part of the quotient this / divisor rounded down. The preferred scale of the result is this.scale() - divisor.scale().
    
    Parameters:
    
    divisor - value by which this BigDecimal is to be divided.
    
    Returns:
    
    The integer part of this / divisor.
    
    Throws:
    
    ArithmeticException - if divisor==0
    
    See Also:
    
    BigDecimal.divideToIntegralValue(java.math.BigDecimal)
  - divideToIntegralValue
```
MonetaryAmount divideToIntegralValue(Number divisor)
```
    Returns a MonetaryAmount whose value is the integer part of the quotient this / divisor rounded down. The preferred scale of the result is this.scale() - divisor.scale().
    
    Parameters:
    
    divisor - value by which this BigDecimal is to be divided.
    
    Returns:
    
    The integer part of this / divisor.
    
    Throws:
    
    ArithmeticException - if divisor==0
    
    See Also:
    
    BigDecimal.divideToIntegralValue(java.math.BigDecimal)
  - scaleByPowerOfTen
```
MonetaryAmount scaleByPowerOfTen(int power)
```
    Returns a MonetaryAmount whose numerical value is equal to ( this * 10ⁿ). The scale of the result is this.scale() - n.
    
    Parameters:
    
    power - the power.
    
    Returns:
    
    the calculated amount value.
    
    Throws:
    
    ArithmeticException - if the scale would be outside the range of a 32-bit integer, or if the result exceeds the numeric capabilities of this implementation class, i.e. the MonetaryContext cannot be adapted as required.
  - abs
```
MonetaryAmount abs()
```
    Returns a MonetaryAmount whose value is the absolute value of this MonetaryAmount, and whose scale is this.scale().
    
    Returns:
    
    abs(this
  - negate
```
MonetaryAmount negate()
```
    Returns a MonetaryAmount whose value is -this, and whose scale is this.scale().
    
    Returns:
    
    -this.
  - plus
```
MonetaryAmount plus()
```
    Returns a MonetaryAmount whose value is +this, with rounding according to the context settings.
    
    Returns:
    
    this, rounded as necessary. A zero result will have a scale of 0.
    
    Throws:
    
    ArithmeticException - if rounding fails.
    
    See Also:
    
    BigDecimal.plus()
  - stripTrailingZeros
```
MonetaryAmount stripTrailingZeros()
```
    Returns a MonetaryAmount which is numerically equal to this one but with any trailing zeros removed from the representation. For example, stripping the trailing zeros from the MonetaryAmount value CHF 600.0, which has [BigInteger, scale] components equals to [6000, 1], yields 6E2 with [ BigInteger, scale] components equals to [6, -2]
    
    Returns:
    
    a numerically equal MonetaryAmount with any trailing zeros removed.

Interface MonetaryAmount

Implementation specification

Method Summary

Methods inherited from interface javax.money.CurrencySupplier

Methods inherited from interface javax.money.NumberSupplier

Methods inherited from interface java.lang.Comparable

Method Detail

getContext

query

with

getFactory

isGreaterThan

isGreaterThanOrEqualTo

isLessThan

isLessThanOrEqualTo

isEqualTo

isNegative

isNegativeOrZero

isPositive

isPositiveOrZero

isZero

signum

add

subtract

multiply

multiply

multiply

divide

divide

divide

remainder

remainder

remainder

divideAndRemainder

divideAndRemainder

divideAndRemainder

divideToIntegralValue

divideToIntegralValue

divideToIntegralValue

scaleByPowerOfTen

abs

negate

plus

stripTrailingZeros