Java 9中新的货币API

发表于：2015-1-08 09:07 作者：Michael Scharhag 来源：51Testing软件测试网采编

字体：大中小 | 上一篇 | 下一篇 |我要投稿 | 推荐标签：

　　MonetaryAmount的使用

　　可以在MonetaryAmount上进行算术运算：

　　MonetaryAmount twelveEuro = fiveEuro.add(sevenEuro); // "EUR 12"

　　MonetaryAmount twoEuro = sevenEuro.subtract(fiveEuro); // "EUR 2"

　　MonetaryAmount sevenPointFiveEuro = fiveEuro.multiply(1.5); // "EUR 7.5"

　　// MonetaryAmount can have a negative NumberValue

　　MonetaryAmount minusTwoEuro = fiveEuro.subtract(sevenEuro); // "EUR -2"

　　// some useful utility methods

　　boolean greaterThan = sevenEuro.isGreaterThan(fiveEuro); // true

　　boolean positive = sevenEuro.isPositive(); // true

　　boolean zero = sevenEuro.isZero(); // false

　　// Note that MonetaryAmounts need to have the same CurrencyUnit to do mathematical operations

　　// this fails with: javax.money.MonetaryException: Currency mismatch: EUR/USD

　　fiveEuro.add(tenUsDollar);

　　舍入操作是金额换算里面非常重要的一部分。MonetaryAmount可以使用舍入操作符来进行四舍五入：

　　CurrencyUnit usd = MonetaryCurrencies.getCurrency("USD");

　　MonetaryAmount dollars = Money.of(12.34567, usd);

　　MonetaryOperator roundingOperator = MonetaryRoundings.getRounding(usd);

　　MonetaryAmount roundedDollars = dollars.with(roundingOperator); // USD 12.35

　　这里12.3456美金就会按当前货币默认的舍入规则来进行换算。

　　在操作MonetaryAmount集合时，有许多实用的工具方法可以用来进行过滤，排序以及分组。这些方法还可以与Java 8的流API一起配套使用。

　　看一下下面这个集合：

　　List<MonetaryAmount> amounts = new ArrayList<>();

　　amounts.add(Money.of(2, "EUR"));

　　amounts.add(Money.of(42, "USD"));

　　amounts.add(Money.of(7, "USD"));

　　amounts.add(Money.of(13.37, "JPY"));

　　amounts.add(Money.of(18, "USD"));

　　我们可以根据CurrencyUnit来进行金额过滤：

　　CurrencyUnit yen = MonetaryCurrencies.getCurrency("JPY");

　　CurrencyUnit dollar = MonetaryCurrencies.getCurrency("USD");

　　// 根据货币过滤，只返回美金

　　// result is [USD 18, USD 7, USD 42]

　　List<MonetaryAmount> onlyDollar = amounts.stream()

　　.filter(MonetaryFunctions.isCurrency(dollar))

　　.collect(Collectors.toList());

　　// 根据货币过滤，只返回美金和日元

　　// [USD 18, USD 7, JPY 13.37, USD 42]

　　List<MonetaryAmount> onlyDollarAndYen = amounts.stream()

　　.filter(MonetaryFunctions.isCurrency(dollar, yen))

　　.collect(Collectors.toList());

　　我们还可以过滤出大于或小于某个阈值的金额：

　　MonetaryAmount tenDollar = Money.of(10, dollar);

　　// [USD 42, USD 18]

　　List<MonetaryAmount> greaterThanTenDollar = amounts.stream()

　　.filter(MonetaryFunctions.isCurrency(dollar))

　　.filter(MonetaryFunctions.isGreaterThan(tenDollar))

　　.collect(Collectors.toList());

　　排序也是类似的：

　　// Sorting dollar values by number value

　　// [USD 7, USD 18, USD 42]

　　List<MonetaryAmount> sortedByAmount = onlyDollar.stream()

　　.sorted(MonetaryFunctions.sortNumber())

　　.collect(Collectors.toList());

　　// Sorting by CurrencyUnit

　　// [EUR 2, JPY 13.37, USD 42, USD 7, USD 18]

　　List<MonetaryAmount> sortedByCurrencyUnit = amounts.stream()

　　.sorted(MonetaryFunctions.sortCurrencyUnit())

　　.collect(Collectors.toList());

　　还有分组操作：

　　// 按货币单位进行分组

　　// {USD=[USD 42, USD 7, USD 18], EUR=[EUR 2], JPY=[JPY 13.37]}

　　Map<CurrencyUnit, List<MonetaryAmount>> groupedByCurrency = amounts.stream()

　　.collect(MonetaryFunctions.groupByCurrencyUnit());

　　// 分组并进行汇总

　　Map<CurrencyUnit, MonetarySummaryStatistics> summary = amounts.stream()

　　.collect(MonetaryFunctions.groupBySummarizingMonetary()).get();

　　// get summary for CurrencyUnit USD

　　MonetarySummaryStatistics dollarSummary = summary.get(dollar);

　　MonetaryAmount average = dollarSummary.getAverage(); // "USD 22.333333333333333333.."

　　MonetaryAmount min = dollarSummary.getMin(); // "USD 7"

　　MonetaryAmount max = dollarSummary.getMax(); // "USD 42"

　　MonetaryAmount sum = dollarSummary.getSum(); // "USD 67"

　　long count = dollarSummary.getCount(); // 3

　　MonetaryFunctions还提供了归约函数，可以用来获取最大值，最小值，以及求和：

　　List<MonetaryAmount> amounts = new ArrayList<>();

　　amounts.add(Money.of(10, "EUR"));

　　amounts.add(Money.of(7.5, "EUR"));

　　amounts.add(Money.of(12, "EUR"));

　　Optional<MonetaryAmount> max = amounts.stream().reduce(MonetaryFunctions.max()); // "EUR 7.5"

　　Optional<MonetaryAmount> min = amounts.stream().reduce(MonetaryFunctions.min()); // "EUR 12"

　　Optional<MonetaryAmount> sum = amounts.stream().reduce(MonetaryFunctions.sum()); // "EUR 29.5"

　　自定义的MonetaryAmount操作

　　MonetaryAmount还提供了一个非常友好的扩展点叫作MonetaryOperator。MonetaryOperator是一个函数式接口，它接收一个MonetaryAmount入参并返回一个新的MonetaryAmount对象。

　　// A monetary operator that returns 10% of the input MonetaryAmount

　　// Implemented using Java 8 Lambdas

　　MonetaryOperator tenPercentOperator = (MonetaryAmount amount) -> {

　　BigDecimal baseAmount = amount.getNumber().numberValue(BigDecimal.class);

　　BigDecimal tenPercent = baseAmount.multiply(new BigDecimal("0.1"));

　　return Money.of(tenPercent, amount.getCurrency());

　　};

　　MonetaryAmount dollars = Money.of(12.34567, "USD");

　　// apply tenPercentOperator to MonetaryAmount

　　MonetaryAmount tenPercentDollars = dollars.with(tenPercentOperator); // USD 1.234567

　　标准的API特性都是通过MonetaryOperator的接口来实现的。比方说，前面看到的舍入操作就是以MonetaryOperator接口的形式来提供的。

　　汇率

　　货币兑换率可以通过ExchangeRateProvider来获取。JavaMoney自带了多个不同的ExchangeRateProvider的实现。其中最重要的两个是ECBCurrentRateProvider与 IMFRateProvider。

　　ECBCurrentRateProvider查询的是欧洲中央银行(European Central Bank,ECB)的数据而IMFRateProvider查询的是国际货币基金组织（International Monetary Fund，IMF）的汇率。

　　// get the default ExchangeRateProvider (CompoundRateProvider)

　　ExchangeRateProvider exchangeRateProvider = MonetaryConversions.getExchangeRateProvider();

　　// get the names of the default provider chain

　　// [IDENT, ECB, IMF, ECB-HIST]

　　List<String> defaultProviderChain = MonetaryConversions.getDefaultProviderChain();

　　// get a specific ExchangeRateProvider (here ECB)

　　ExchangeRateProvider ecbExchangeRateProvider = MonetaryConversions.getExchangeRateProvider("ECB");

32/3<123 >

文章资料精选

关注51Testing