FastMoney (Moneta (JSR 354 RI) for Java 7 1.4.1 API)

java.lang.Object
- org.javamoney.moneta.FastMoney

All Implemented Interfaces:

Serializable, Comparable<MonetaryAmount>, CurrencySupplier, MonetaryAmount, NumberSupplier
```
public final class FastMoney
extends Object
implements MonetaryAmount, Comparable<MonetaryAmount>, Serializable
```
long based implementation of MonetaryAmount.This class internally uses a single long number as numeric representation, which basically is interpreted as minor units. It suggested to have a performance advantage of a 10-15 times faster compared to Money, which internally uses BigDecimal. Nevertheless this comes with a price of less precision. As an example performing the following calculation one million times, results in slightly different results:
```
 Money money1 = money1.add(Money.of("EUR", 1234567.3444));
 money1 = money1.subtract(Money.of("EUR", 232323));
 money1 = money1.multiply(3.4);
 money1 = money1.divide(5.456);
 
```
Executed one million (1000000) times this results in EUR 1657407.962529182, calculated in 3680 ms, or roughly 3ns/loop. whereas
```
 FastMoney money1 = money1.add(FastMoney.of("EUR", 1234567.3444));
 money1 = money1.subtract(FastMoney.of("EUR", 232323));
 money1 = money1.multiply(3.4);
 money1 = money1.divide(5.456);
 
```
executed one million (1000000) times results in EUR 1657407.96251, calculated in 179 ms, which is less than 1ns/loop. Also note than mixing up types may drastically change the performance behavior. E.g. replacing the code above with the following: *
```
 FastMoney money1 = money1.add(Money.of("EUR", 1234567.3444));
 money1 = money1.subtract(FastMoney.of("EUR", 232323));
 money1 = money1.multiply(3.4);
 money1 = money1.divide(5.456);
 
```
executed one million (1000000) times may execute significantly longer, since monetary amount type conversion is involved. Basically, when mixing amount implementations, the performance of the amount, on which most of the operations are operated, has the most significant impact on the overall performance behavior.
Since:

1.0

Version:

1.0.1

Author:

Anatole Tresch, Werner Keil

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static FastMoney`	`MAX_VALUE` Maximum possible value supported, using XX (no currency).
`static FastMoney`	`MIN_VALUE` Minimum possible value supported, using XX (no currency).

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FastMoney`	`abs()`
`FastMoney`	`add(MonetaryAmount amount)`
`protected void`	`checkNumber(Number number)` Internal method to check for correct number parameter.
`int`	`compareTo(MonetaryAmount o)`
`FastMoney`	`divide(double divisor)`
`FastMoney`	`divide(long divisor)`
`FastMoney`	`divide(Number divisor)`
`FastMoney[]`	`divideAndRemainder(double divisor)`
`FastMoney[]`	`divideAndRemainder(long divisor)`
`FastMoney[]`	`divideAndRemainder(Number divisor)`
`FastMoney`	`divideToIntegralValue(double divisor)`
`FastMoney`	`divideToIntegralValue(long divisor)`
`FastMoney`	`divideToIntegralValue(Number divisor)`
`boolean`	`equals(Object obj)`
`static FastMoney`	`from(MonetaryAmount amount)`
`MonetaryContext`	`getContext()` Access the `MonetaryContext` used by this instance.
`CurrencyUnit`	`getCurrency()` Returns the amount’s currency, modelled as `CurrencyUnit`.
`MonetaryAmountFactory<FastMoney>`	`getFactory()`
`NumberValue`	`getNumber()` Gets the number representation of the numeric value of this item.
`int`	`getPrecision()`
`int`	`getScale()`
`int`	`hashCode()`
`boolean`	`hasSameNumberAs(Number number)`
`boolean`	`isEqualTo(MonetaryAmount amount)`
`boolean`	`isGreaterThan(MonetaryAmount amount)`
`boolean`	`isGreaterThan(Number number)`
`boolean`	`isGreaterThanOrEqualTo(MonetaryAmount amount)`
`boolean`	`isGreaterThanOrEqualTo(Number number)`
`boolean`	`isLessThan(MonetaryAmount amount)`
`boolean`	`isLessThan(Number number)`
`boolean`	`isLessThanOrEqualTo(MonetaryAmount amount)`
`boolean`	`isLessThanOrEqualTo(Number number)`
`boolean`	`isNegative()`
`boolean`	`isNegativeOrZero()`
`boolean`	`isPositive()`
`boolean`	`isPositiveOrZero()`
`boolean`	`isZero()`
`FastMoney`	`multiply(double multiplicand)`
`FastMoney`	`multiply(long multiplicand)`
`FastMoney`	`multiply(Number multiplicand)`
`FastMoney`	`negate()`
`static FastMoney`	`of(Number number, CurrencyUnit currency)` Static factory method for creating a new instance of `FastMoney`.
`static FastMoney`	`of(Number number, String currencyCode)` Static factory method for creating a new instance of `FastMoney`.
`static FastMoney`	`of(NumberValue numberBinding, CurrencyUnit currency)` Static factory method for creating a new instance of `FastMoney`.
`static FastMoney`	`ofMinor(CurrencyUnit currency, long amountMinor)` Obtains an instance of `FastMoney` from an amount in minor units.
`static FastMoney`	`ofMinor(CurrencyUnit currency, long amountMinor, int factionDigits)` Obtains an instance of `FastMoney` from an amount in minor units.
`static FastMoney`	`parse(CharSequence text)` Obtains an instance of FastMoney from a text string such as 'EUR 25.25'.
`static FastMoney`	`parse(CharSequence text, MonetaryAmountFormat formatter)` Obtains an instance of FastMoney from a text using specific formatter.
`FastMoney`	`plus()`
`<R> R`	`query(MonetaryQuery<R> query)`
`FastMoney`	`remainder(double divisor)`
`FastMoney`	`remainder(long divisor)`
`FastMoney`	`remainder(Number divisor)`
`FastMoney`	`scaleByPowerOfTen(int n)`
`int`	`signum()`
`FastMoney`	`stripTrailingZeros()`
`FastMoney`	`subtract(MonetaryAmount subtrahend)`
`String`	`toString()`
`FastMoney`	`with(MonetaryOperator operator)`
`static FastMoney`	`zero(CurrencyUnit currency)` Obtains an instance of `FastMoney` representing zero.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - MAX_VALUE
```
public static final FastMoney MAX_VALUE
```
    Maximum possible value supported, using XX (no currency).
  - MIN_VALUE
```
public static final FastMoney MIN_VALUE
```
    Minimum possible value supported, using XX (no currency).
- Method Detail
  - getCurrency
```
public CurrencyUnit getCurrency()
```
    Returns the amount’s currency, modelled as CurrencyUnit. Implementations may co-variantly change the return type to a more specific implementation of CurrencyUnit if desired.
    
    Specified by:
    
    getCurrency in interface CurrencySupplier
    
    Returns:
    
    the currency, never null
    
    See Also:
    
    CurrencySupplier.getCurrency()
  - getContext
```
public MonetaryContext getContext()
```
    Access the MonetaryContext used by this instance.
    
    Specified by:
    
    getContext in interface MonetaryAmount
    
    Returns:
    
    the MonetaryContext used, never null.
    
    See Also:
    
    MonetaryAmount.getContext()
  - of
```
public static FastMoney of(NumberValue numberBinding,
                           CurrencyUnit currency)
```
    Static factory method for creating a new instance of FastMoney.
    
    Parameters:
    
    currency - The target currency, not null.
    
    numberBinding - The numeric part, not null.
    
    Returns:
    
    A new instance of FastMoney.
  - of
```
public static FastMoney of(Number number,
                           CurrencyUnit currency)
```
    Static factory method for creating a new instance of FastMoney.
    
    Parameters:
    
    currency - The target currency, not null.
    
    number - The numeric part, not null.
    
    Returns:
    
    A new instance of FastMoney.
  - of
```
public static FastMoney of(Number number,
                           String currencyCode)
```
    Static factory method for creating a new instance of FastMoney.
    
    Parameters:
    
    currencyCode - The target currency as currency code.
    
    number - The numeric part, not null.
    
    Returns:
    
    A new instance of FastMoney.
  - zero
```
public static FastMoney zero(CurrencyUnit currency)
```
    Obtains an instance of FastMoney representing zero.
    
    Parameters:
    
    currency - the target currency
    
    Returns:
    
    an instance of FastMoney representing zero.
    
    Since:
    
    1.0.1
  - ofMinor
```
public static FastMoney ofMinor(CurrencyUnit currency,
                                long amountMinor)
```
    Obtains an instance of FastMoney from an amount in minor units. For example, ofMinor(USD, 1234) creates the instance USD 12.34.
    
    Parameters:
    
    currency - the currency, not null
    
    amountMinor - the amount of money in the minor division of the currency
    
    Returns:
    
    the monetary amount from minor units
    
    Throws:
    
    NullPointerException - when the currency is null
    
    IllegalArgumentException - when CurrencyUnit.getDefaultFractionDigits() is lesser than zero.
    
    Since:
    
    1.0.1
    
    See Also:
    
    CurrencyUnit.getDefaultFractionDigits(), ofMinor(CurrencyUnit, long, int)
  - ofMinor
```
public static FastMoney ofMinor(CurrencyUnit currency,
                                long amountMinor,
                                int factionDigits)
```
    Obtains an instance of FastMoney from an amount in minor units. For example, ofMinor(USD, 1234, 2) creates the instance USD 12.34.
    
    Parameters:
    
    currency - the currency, not null
    
    amountMinor - the amount of money in the minor division of the currency
    
    factionDigits - number of digits
    
    Returns:
    
    the monetary amount from minor units
    
    Throws:
    
    NullPointerException - when the currency is null
    
    IllegalArgumentException - when the factionDigits is negative
    
    Since:
    
    1.0.1
    
    See Also:
    
    CurrencyUnit.getDefaultFractionDigits()
  - compareTo
```
public int compareTo(MonetaryAmount o)
```
    Specified by:
    
    compareTo in interface Comparable<MonetaryAmount>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - abs
```
public FastMoney abs()
```
    Specified by:
    
    abs in interface MonetaryAmount
  - add
```
public FastMoney add(MonetaryAmount amount)
```
    Specified by:
    
    add in interface MonetaryAmount
  - divide
```
public FastMoney divide(Number divisor)
```
    Specified by:
    
    divide in interface MonetaryAmount
  - divideAndRemainder
```
public FastMoney[] divideAndRemainder(Number divisor)
```
    Specified by:
    
    divideAndRemainder in interface MonetaryAmount
  - divideToIntegralValue
```
public FastMoney divideToIntegralValue(Number divisor)
```
    Specified by:
    
    divideToIntegralValue in interface MonetaryAmount
  - multiply
```
public FastMoney multiply(Number multiplicand)
```
    Specified by:
    
    multiply in interface MonetaryAmount
  - negate
```
public FastMoney negate()
```
    Specified by:
    
    negate in interface MonetaryAmount
  - plus
```
public FastMoney plus()
```
    Specified by:
    
    plus in interface MonetaryAmount
  - subtract
```
public FastMoney subtract(MonetaryAmount subtrahend)
```
    Specified by:
    
    subtract in interface MonetaryAmount
  - remainder
```
public FastMoney remainder(Number divisor)
```
    Specified by:
    
    remainder in interface MonetaryAmount
  - scaleByPowerOfTen
```
public FastMoney scaleByPowerOfTen(int n)
```
    Specified by:
    
    scaleByPowerOfTen in interface MonetaryAmount
  - isZero
```
public boolean isZero()
```
    Specified by:
    
    isZero in interface MonetaryAmount
  - isPositive
```
public boolean isPositive()
```
    Specified by:
    
    isPositive in interface MonetaryAmount
  - isPositiveOrZero
```
public boolean isPositiveOrZero()
```
    Specified by:
    
    isPositiveOrZero in interface MonetaryAmount
  - isNegative
```
public boolean isNegative()
```
    Specified by:
    
    isNegative in interface MonetaryAmount
  - isNegativeOrZero
```
public boolean isNegativeOrZero()
```
    Specified by:
    
    isNegativeOrZero in interface MonetaryAmount
  - getScale
```
public int getScale()
```
  - getPrecision
```
public int getPrecision()
```
  - signum
```
public int signum()
```
    Specified by:
    
    signum in interface MonetaryAmount
  - isLessThan
```
public boolean isLessThan(MonetaryAmount amount)
```
    Specified by:
    
    isLessThan in interface MonetaryAmount
  - isLessThan
```
public boolean isLessThan(Number number)
```
  - isLessThanOrEqualTo
```
public boolean isLessThanOrEqualTo(MonetaryAmount amount)
```
    Specified by:
    
    isLessThanOrEqualTo in interface MonetaryAmount
  - isLessThanOrEqualTo
```
public boolean isLessThanOrEqualTo(Number number)
```
  - isGreaterThan
```
public boolean isGreaterThan(MonetaryAmount amount)
```
    Specified by:
    
    isGreaterThan in interface MonetaryAmount
  - isGreaterThan
```
public boolean isGreaterThan(Number number)
```
  - isGreaterThanOrEqualTo
```
public boolean isGreaterThanOrEqualTo(MonetaryAmount amount)
```
    Specified by:
    
    isGreaterThanOrEqualTo in interface MonetaryAmount
  - isGreaterThanOrEqualTo
```
public boolean isGreaterThanOrEqualTo(Number number)
```
  - isEqualTo
```
public boolean isEqualTo(MonetaryAmount amount)
```
    Specified by:
    
    isEqualTo in interface MonetaryAmount
  - hasSameNumberAs
```
public boolean hasSameNumberAs(Number number)
```
  - getNumber
```
public NumberValue getNumber()
```
    Gets the number representation of the numeric value of this item.
    
    Specified by:
    
    getNumber in interface NumberSupplier
    
    Returns:
    
    The Number represention matching best.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - checkNumber
```
protected void checkNumber(Number number)
```
    Internal method to check for correct number parameter.
    
    Parameters:
    
    number - the number to be checked, including null..
    
    Throws:
    
    NullPointerException - If the number is null
    
    ArithmeticException - If the number exceeds the capabilities of this class.
  - with
```
public FastMoney with(MonetaryOperator operator)
```
    Specified by:
    
    with in interface MonetaryAmount
  - query
```
public <R> R query(MonetaryQuery<R> query)
```
    Specified by:
    
    query in interface MonetaryAmount
  - from
```
public static FastMoney from(MonetaryAmount amount)
```
  - parse
```
public static FastMoney parse(CharSequence text)
```
    Obtains an instance of FastMoney from a text string such as 'EUR 25.25'.
    
    Parameters:
    
    text - the text to parse not null
    
    Returns:
    
    FastMoney instance
    
    Throws:
    
    NumberFormatException - if the amount is not a number
    
    UnknownCurrencyException - if the currency is not resolvable
  - parse
```
public static FastMoney parse(CharSequence text,
                              MonetaryAmountFormat formatter)
```
    Obtains an instance of FastMoney from a text using specific formatter.
    
    Parameters:
    
    text - the text to parse not null
    
    formatter - the formatter to use not null
    
    Returns:
    
    FastMoney instance
  - multiply
```
public FastMoney multiply(double multiplicand)
```
    Specified by:
    
    multiply in interface MonetaryAmount
  - divide
```
public FastMoney divide(long divisor)
```
    Specified by:
    
    divide in interface MonetaryAmount
  - divide
```
public FastMoney divide(double divisor)
```
    Specified by:
    
    divide in interface MonetaryAmount
  - remainder
```
public FastMoney remainder(long divisor)
```
    Specified by:
    
    remainder in interface MonetaryAmount
  - remainder
```
public FastMoney remainder(double divisor)
```
    Specified by:
    
    remainder in interface MonetaryAmount
  - divideAndRemainder
```
public FastMoney[] divideAndRemainder(long divisor)
```
    Specified by:
    
    divideAndRemainder in interface MonetaryAmount
  - divideAndRemainder
```
public FastMoney[] divideAndRemainder(double divisor)
```
    Specified by:
    
    divideAndRemainder in interface MonetaryAmount
  - stripTrailingZeros
```
public FastMoney stripTrailingZeros()
```
    Specified by:
    
    stripTrailingZeros in interface MonetaryAmount
  - multiply
```
public FastMoney multiply(long multiplicand)
```
    Specified by:
    
    multiply in interface MonetaryAmount
  - divideToIntegralValue
```
public FastMoney divideToIntegralValue(long divisor)
```
    Specified by:
    
    divideToIntegralValue in interface MonetaryAmount
  - divideToIntegralValue
```
public FastMoney divideToIntegralValue(double divisor)
```
    Specified by:
    
    divideToIntegralValue in interface MonetaryAmount
  - getFactory
```
public MonetaryAmountFactory<FastMoney> getFactory()
```
    Specified by:
    
    getFactory in interface MonetaryAmount

Class FastMoney

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MAX_VALUE

MIN_VALUE

Method Detail

getCurrency

getContext

of

of

of

zero

ofMinor

ofMinor

compareTo

hashCode

equals

abs

add

divide

divideAndRemainder

divideToIntegralValue

multiply

negate

plus

subtract

remainder

scaleByPowerOfTen

isZero

isPositive

isPositiveOrZero

isNegative

isNegativeOrZero

getScale

getPrecision

signum

isLessThan

isLessThan

isLessThanOrEqualTo

isLessThanOrEqualTo

isGreaterThan

isGreaterThan

isGreaterThanOrEqualTo

isGreaterThanOrEqualTo

isEqualTo

hasSameNumberAs

getNumber

toString

checkNumber

with

query

from

parse

parse

multiply

divide

divide

remainder

remainder

divideAndRemainder

divideAndRemainder

stripTrailingZeros

multiply

divideToIntegralValue

divideToIntegralValue

getFactory