import javax.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void shouldGroupByCorrectly() {
	GroupMonetarySummaryStatistics group = createGroupMonetary();

	Map<CurrencyUnit, MonetarySummaryStatistics> map = group.get();
	Assert.assertEquals(map.keySet().size(), 3);
	Assert.assertNotNull(map.get(BRAZILIAN_REAL));
	Assert.assertNotNull(map.get(EURO));
	Assert.assertNotNull(map.get(DOLLAR));

	MonetarySummaryStatistics brazilianSummary = map
			.get(BRAZILIAN_REAL);
	verifySummary(brazilianSummary, 15, 30, 2L);

	MonetarySummaryStatistics euroSummary = map.get(EURO);
	verifySummary(euroSummary, 50, 100, 2L);

	MonetarySummaryStatistics dollarSummary = map.get(DOLLAR);
	verifySummary(dollarSummary, 60, 120, 2L);

}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
public static void main(String[] args) {
    CurrencyUnit dollar = Monetary.getCurrency("USD");
    CurrencyUnit real = Monetary.getCurrency("BRL");



    MonetaryAmount money = Money.of(10, dollar);
    MonetaryAmount money2 = Money.of(10, real);
    MonetaryAmount money3 = Money.of(10, dollar);
    MonetaryAmount money4 = Money.of(9, real);
    MonetaryAmount money5 = Money.of(25, dollar);

    GroupMonetarySummaryStatistics grouped = Stream.of(money, money2, money3, money4, money5)
    .collect(MonetaryFunctions.groupBySummarizingMonetary());
    Map<CurrencyUnit, MonetarySummaryStatistics> mapSummary = grouped.get();
    MonetarySummaryStatistics summary = mapSummary.get(dollar);

    MonetaryAmount min = summary.getMin();//USD 10
    MonetaryAmount max = summary.getMax();//USD 25
    MonetaryAmount average = summary.getAverage();//USD 15
    long count = summary.getCount();//3
    MonetaryAmount sum = summary.getSum();//USD 45

}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
public static void main(String[] args) {
    CurrencyUnit dollar = Monetary.getCurrency("USD");
    CurrencyUnit euro = Monetary.getCurrency("EUR");
    CurrencyUnit real = Monetary.getCurrency("BRL");

    MonetaryAmount money = Money.of(9, euro);
    MonetaryAmount money2 = Money.of(10, dollar);
    MonetaryAmount money3 = Money.of(11, real);

    List<MonetaryAmount> resultAsc = Stream.of(money, money2, money3)
            .sorted(MonetaryFunctions
                    .sortCurrencyUnit()).collect(Collectors.toList());//[BRL 11, EUR 9, USD 10]
    List<MonetaryAmount> resultDesc = Stream.of(money, money2, money3)
            .sorted(MonetaryFunctions
                    .sortCurrencyUnitDesc()).collect(Collectors.toList());//[USD 10, EUR 9, BRL 11]

}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
public static void main(String[] args) {
    CurrencyUnit dollar = Monetary.getCurrency("USD");
    CurrencyUnit euro = Monetary.getCurrency("EUR");
    CurrencyUnit real = Monetary.getCurrency("BRL");

    MonetaryAmount money = Money.of(9, euro);
    MonetaryAmount money2 = Money.of(10, dollar);
    MonetaryAmount money3 = Money.of(11, real);

    ExchangeRateProvider provider =
            MonetaryConversions.getExchangeRateProvider(ExchangeRateType.IMF);

    ;
    List<MonetaryAmount> resultAsc = Stream.of(money, money2, money3)
            .sorted(MonetaryFunctions
                    .sortValuable(provider))
            .collect(Collectors.toList());//[BRL 11, EUR 9, USD 10]

    List<MonetaryAmount> resultDesc = Stream.of(money, money2, money3)
            .sorted(MonetaryFunctions
                    .sortValuableDesc(provider)).collect(Collectors.toList());//[USD 10, EUR 9, BRL 11]

}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
public static void main(String[] args) {
    CurrencyUnit dollar = Monetary.getCurrency("USD");



    MonetaryAmount money = Money.of(10, dollar);
    MonetaryAmount money2 = Money.of(10, dollar);
    MonetaryAmount money3 = Money.of(10, dollar);
    MonetaryAmount money4 = Money.of(9, dollar);
    MonetaryAmount money5 = Money.of(8, dollar);

    List<MonetaryAmount> greaterThanZero = Stream.of(money, money2, money3, money4, money5)
            .filter(MonetaryFunctions.isGreaterThan(Money.zero(dollar)))
            .collect(Collectors.toList());//[USD 10, USD 10, USD 10, USD 9, USD 8]

    boolean hasAnyGreaterThanZero = Stream.of(money, money2, money3, money4, money5)
            .anyMatch(MonetaryFunctions.isGreaterThan(Money.zero(dollar)));//true

    boolean allBetweenZeroAndTen = Stream.of(money, money2, money3, money4, money5)
            .allMatch(MonetaryFunctions.isBetween(Money.zero(dollar),
                    Money.of(BigDecimal.TEN, dollar)));//true

}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
public static void main(String[] args) {
    CurrencyUnit currency = Monetary.getCurrency("BRL");
    CurrencyUnit dollar = Monetary.getCurrency(Locale.US);

    MonetaryAmount money = Money.of(120.231, currency);

    MonetaryAmount majorPartResult = money.with(MonetaryOperators.majorPart());//BRL 120
    MonetaryAmount minorPartResult = money.with(MonetaryOperators.minorPart());//BRL 0.231
    MonetaryAmount percentResult = money.with(MonetaryOperators.percent(20));//BRL 24.0462
    MonetaryAmount permilResult = money.with(MonetaryOperators.permil(100));//BRL 12.0231
    MonetaryAmount roundingResult = money.with(MonetaryOperators.rounding());//BRL 120.23
    MonetaryAmount resultExchange = money.with(ConversionOperators.exchange(dollar));//USD 120.231
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
@Deprecated
public RoundedMoney(Number number, CurrencyUnit currency, MonetaryContext context, MonetaryOperator rounding) {
    Objects.requireNonNull(currency, "Currency is required.");
    this.currency = currency;
    Objects.requireNonNull(number, "Number is required.");
    checkNumber(number);
    MonetaryContextBuilder monetaryContextBuilder = DEFAULT_MONETARY_CONTEXT.toBuilder();
    if (context != null) {
        monetaryContextBuilder.importContext(context);
    }
    this.rounding = RoundedMoneyMonetaryOperatorFactory.INSTANCE.getDefaultMonetaryOperator(rounding, monetaryContextBuilder.build());
    monetaryContextBuilder.set(MONETARY_ROUNDING_KEY, this.rounding);

    this.monetaryContext = monetaryContextBuilder.build();
    this.number = MoneyUtils.getBigDecimal(number, monetaryContext);
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void shouldRoundedMonetaryOperatorWhenTheImplementationIsMoney() {
	int scale = 3;
	int precision = 5;

	CurrencyUnit real = Monetary.getCurrency("BRL");
	BigDecimal valueOf = BigDecimal.valueOf(35.34567);
	MonetaryAmount money = Money.of(valueOf, real);

	MathContext mathContext = new MathContext(precision, RoundingMode.HALF_EVEN);
	PrecisionScaleRoundedOperator monetaryOperator = PrecisionScaleRoundedOperator.of(scale, mathContext);

	MonetaryAmount result = monetaryOperator.apply(money);
	assertTrue(RoundedMoney.class.isInstance(result));
	assertEquals(result.getCurrency(), real);
	assertEquals(result.getNumber().getScale(), scale);
	assertEquals(result.getNumber().getPrecision(), precision);
	assertEquals(BigDecimal.valueOf(35.346), result.getNumber().numberValue(BigDecimal.class));



}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
/**
 * Given a source transfer, compute the amount (in local units of the destination ledger) that should be transferred
 * to the next-hop local ledger.
 *
 * @param sourceTransfer          A {@link Transfer} with information from the incoming source transfer delivered to
 *                                this connector as part of a broader Interledger payment.
 * @param destinationLedgerPrefix An {@link InterledgerAddress} prefix for the destination ledger that the next-hop
 *                                tranfser will be delivered on.
 */
@VisibleForTesting
protected BigInteger computeNextHopLocalTransferAmount(
    final Transfer sourceTransfer,
    final InterledgerAddress destinationLedgerPrefix
) {
  Objects.requireNonNull(sourceTransfer);
  InterledgerAddress.requireAddressPrefix(destinationLedgerPrefix);

  final CurrencyUnit baseCurrencyUnit = this.ledgerPluginManager.getLedgerPlugin(sourceTransfer.getLedgerPrefix())
      .map(LedgerPlugin::getLedgerInfo)
      .map(LedgerInfo::getCurrencyUnit)
      .orElseThrow(() -> new LedgerPluginNotConnectedException(sourceTransfer.getLedgerPrefix()));

  final CurrencyUnit terminatingCurrencyUnit = this.ledgerPluginManager.getLedgerPlugin(destinationLedgerPrefix)
      .map(LedgerPlugin::getLedgerInfo)
      .map(LedgerInfo::getCurrencyUnit)
      .orElseThrow(() -> new LedgerPluginNotConnectedException(destinationLedgerPrefix));

  // This method does not catch the CurrencyConversionException because there's nothing to be done if that occurs. It
  // means that FX is not configured between the source/destination ledgers.
  return Optional.ofNullable(this.fxEngine.getExchangeRate(baseCurrencyUnit, terminatingCurrencyUnit))
      .map(fxRate -> {
        final MonetaryAmount sourceTransferMonetaryAmount = Money.of(sourceTransfer.getAmount(), baseCurrencyUnit);
        final CurrencyConversion conversion = MonetaryConversions.getConversion(terminatingCurrencyUnit);
        final MonetaryAmount terminatingMonetaryAmount = sourceTransferMonetaryAmount.with(conversion);
        return terminatingMonetaryAmount;
      })
      // Convert from a MonetaryAmount back to an Integer...
      .map(MonetaryAmount::getNumber)
      .map(numberValue -> numberValue.numberValueExact(BigInteger.class))
      // This is allowed because if fxEngine.getExchangeRate can't find a rate, it will throw an exception!
      .get();
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
protected ExtendedLedgerPluginConfig getLedgerPluginConfig(final InterledgerAddress ledgerPrefix) {
  return new ExtendedLedgerPluginConfig() {

    @Override
    public LedgerPluginTypeId getLedgerPluginTypeId() {
      return LedgerPluginTypeId.of("ilp-plugin-mock");
    }

    @Override
    public InterledgerAddress getLedgerPrefix() {
      return ledgerPrefix;
    }

    @Override
    public InterledgerAddress getConnectorAccount() {
      return ledgerPrefix.with("connector");
    }

    @Override
    public CurrencyUnit getExpectedCurrencyUnit() {
      return Monetary.getCurrency("USD");
    }

    @Override
    public Map<String, String> getOptions() {
      return ImmutableMap.of();
    }

    @Override
    public String getPassword() {
      return "password";
    }
  };
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
protected ExtendedLedgerPluginConfig getLedgerPluginConfig() {
  return new ExtendedLedgerPluginConfig() {

    @Override
    public LedgerPluginTypeId getLedgerPluginTypeId() {
      return LedgerPluginTypeId.of("ilp-plugin-mock");
    }

    @Override
    public InterledgerAddress getLedgerPrefix() {
      return LEDGER_PREFIX;
    }

    @Override
    public InterledgerAddress getConnectorAccount() {
      return CONNECTOR_ACCOUNT_ON_LEDGER;
    }

    @Override
    public CurrencyUnit getExpectedCurrencyUnit() {
      return Monetary.getCurrency("USD");
    }

    @Override
    public Map<String, String> getOptions() {
      return ImmutableMap.of();
    }

    @Override
    public String getPassword() {
      return "password";
    }
  };
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
@Override
public MonetaryAmount parse(String text, Locale locale) throws ParseException {
	CurrencyStyleFormatter formatter = new CurrencyStyleFormatter();
	Currency currency = determineCurrency(text, locale);
	CurrencyUnit currencyUnit = Monetary.getCurrency(currency.getCurrencyCode());
	formatter.setCurrency(currency);
	formatter.setPattern(this.pattern);
	Number numberValue = formatter.parse(text, locale);
	return Monetary.getDefaultAmountFactory().setNumber(numberValue).setCurrency(currencyUnit).create();
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
@Provides
@RequestScoped
public PriceSelection providePriceSelection(final CurrencyUnit currency, final CountryCode country,
                                            final CustomerInSession customerInSession) {
    return PriceSelection.of(currency)
            .withPriceCountry(country)
            .withPriceCustomerGroupId(customerInSession.findCustomerGroupId().orElse(null));
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
@Inject
public CartWithCreditCardFeeViewModelFactory(final CurrencyUnit currency, final PriceFormatter priceFormatter,
                                             final ShippingInfoViewModelFactory shippingInfoViewModelFactory,
                                             final PaymentInfoViewModelFactory paymentInfoViewModelFactory,
                                             final AddressViewModelFactory addressViewModelFactory,
                                             final LineItemExtendedViewModelFactory lineItemExtendedViewModelFactory) {
    super(currency, priceFormatter, shippingInfoViewModelFactory, paymentInfoViewModelFactory, addressViewModelFactory, lineItemExtendedViewModelFactory);
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
@Override
public MonetaryAmount decode(BsonReader reader, DecoderContext decoderContext) {
	reader.readStartDocument();
	CurrencyUnit currency = Monetary.getCurrency(reader.readString(this.currencyKey));
	BigDecimal number = new BigDecimal(
			BigInteger.valueOf(reader.readInt64(this.unscaledKey)),
			reader.readInt32(this.scaleKey));
	reader.readEndDocument();

	return Monetary.getDefaultAmountFactory().setNumber(number).setCurrency(currency)
			.create();
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void shouldCreateSettingCurrencyUnit() {
    CurrencyUnit currencyUnit = Monetary.getCurrency("BRL");
    MonetaryAmountDecimalFormat format = (MonetaryAmountDecimalFormat) MonetaryAmountDecimalFormatBuilder.newInstance().withProducer(new FastMoneyProducer())
            .withCurrencyUnit(currencyUnit).build();
    assertEquals(format.getCurrencyUnit(), currencyUnit);
    assertEquals(format.getProducer().getClass(), FastMoneyProducer.class);
    assertEquals(format.getDecimalFormat().getCurrency().getCurrencyCode(),format.getCurrencyUnit().getCurrencyCode());
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
public static void main(String[] args) {
    CurrencyUnit currency = Monetary.getCurrency("BRL");
    MonetaryAmount money = Money.of(BigDecimal.TEN, currency);
    MonetaryAmount money2 = FastMoney.of(BigDecimal.TEN, currency);
    MonetaryAmount addResult = money.add(money2);//BRL 20 Money implementation
    MonetaryAmount subtractResult = money2.subtract(addResult);//BRL -10 FastMoney implementation
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
/**
 * Test Comparable method for
 * {@link javax.money.CurrencyUnit}s.
 */
@Test
public void testCompareTo() {
	CurrencyUnit cur1 = Monetary.getCurrency("USD");
	CurrencyUnit cur2 = Monetary.getCurrency("EUR");
	assertNotNull(cur1);
       assertNotNull(cur2);
	assertTrue(0 < cur1.compareTo(cur2));
	assertTrue(0 > cur2.compareTo(cur1));
	assertEquals(0, cur1.compareTo(cur1));
	assertEquals(0, cur2.compareTo(cur2));
}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
public static void main(String[] args) {
	MonetaryAmountFormat patternFormat = MonetaryAmountDecimalFormatBuilder.of("¤ ###,###.00").build();
	
    CurrencyUnit currency = Monetary.getCurrency("BRL");
    MonetaryAmount money = Money.of(12, currency);
    String format = patternFormat.format(money);//$ 12.00
    MonetaryAmount moneyParsed = Money.parse(format, patternFormat);//or using defafult.parse(format);

}
 

import javax.money.CurrencyUnit; //导入依赖的package包/类
public static void main(String[] args) {
    CurrencyUnit currency = Monetary.getCurrency(Locale.US);
    MonetaryAmount money = Money.of(10, currency);
    MonetaryAmount money2 = FastMoney.of(20, currency);
    MonetaryAmount money3 = RoundedMoney.of(30, currency, MonetaryOperators.rounding());
    String text = money.toString();//USD 10
    String text2 = money2.toString();//USD 20
    String text3 = money3.toString();//USD 30
    MonetaryAmount result = Money.parse(text);
    MonetaryAmount result2 = FastMoney.parse(text2);
    MonetaryAmount result3 = RoundedMoney.parse(text3);

}