设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java 9中新的货币API

2016-12-20 13:13| 发布者: zhangjf| 查看: 389| 评论: 0

摘要: 译文出处： Java译站 原文出处：Michael Scharhag JSR 354定义了一套新的Java货币API，计划会在Java 9中正式引入。本文中我们将来看一下它的参考实现：JavaMoney的当前进展。 正如我在之前那篇Java 8新的日期时 ...
译文出处： Java译站 原文出处：Michael Scharhag

JSR 354定义了一套新的Java货币API，计划会在Java 9中正式引入。本文中我们将来看一下它的参考实现：JavaMoney的当前进展。

正如我在之前那篇Java 8新的日期时间API一文中那样，本文主要也是通过一些代码来演示下新的API的用法 。

在开始之前，我想先用一段话来简短地总结一下规范定义的这套新的API的用意何在：

对许多应用而言货币价值都是一个关键的特性，但JDK对此却几乎没有任何支持。严格来讲，现有的java.util.Currency类只是代表了当前ISO 4217货币的一个数据结构，但并没有关联的值或者自定义货币。JDK对货币的运算及转换也没有内建的支持，更别说有一个能够代表货币值的标准类型了。

如果你用的是Maven的话，只需把下面的引用添加到工里面便能够体验下该参考实现的当前功能了：

  1. <dependency>
  2. <groupId>org.javamoney</groupId>
  3. <artifactId>moneta</artifactId>
  4. <version>0.9</version>
  5. </dependency>
复制代码

规范中提到的类及接口都在javax.money.*包下面。

我们先从核心的两个接口CurrencyUnit与MonetaryAmount开始讲起。

CurrencyUnit及MonetaryAmount

CurrencyUnit代表的是货币。它有点类似于现在的java.util.Currency类，不同之处在于它支持自定义的实现。从规范的定义来看，java.util.Currency也是可以实现该接口的。CurrencyUnit的实例可以通过MonetaryCurrencies工厂来获取：

  1. // 根据货币代码来获取货币单位
  2. CurrencyUnit euro = MonetaryCurrencies.getCurrency("EUR");
  3. CurrencyUnit usDollar = MonetaryCurrencies.getCurrency("USD");
  5. // 根据国家及地区来获取货币单位
  6. CurrencyUnit yen = MonetaryCurrencies.getCurrency(Locale.JAPAN);
  7. CurrencyUnit canadianDollar = MonetaryCurrencies.getCurrency(Locale.CANADA);
复制代码

MontetaryAmount代表的是某种货币的具体金额。通常它都会与某个CurrencyUnit绑定。MontetaryAmount和CurrencyUnit一样，也是一个能支持多种实现的接口。CurrencyUnit与MontetaryAmount的实现必须是不可变，线程安全且可比较的。

  1. / get MonetaryAmount from CurrencyUnit
  2. CurrencyUnit euro = MonetaryCurrencies.getCurrency("EUR");
  3. MonetaryAmount fiveEuro = Money.of(5, euro);
  5. // get MonetaryAmount from currency code
  6. MonetaryAmount tenUsDollar = Money.of(10, "USD");
  8. // FastMoney is an alternative MonetaryAmount factory that focuses on performance
  9. MonetaryAmount sevenEuro = FastMoney.of(7, euro);
复制代码

Money与FastMoney是JavaMoney库中MonetaryAmount的两种实现。Money是默认实现，它使用BigDecimal来存储金额。FastMoney是可选的另一个实现，它用long类型来存储金额。根据文档来看，FastMoney上的操作要比Money的快10到15倍左右。然而，FastMoney的金额大小与精度都受限于long类型。

注意了，这里的Money和FastMoney都是具体的实现类（它们在org.javamoney.moneta.*包下面，而不是javax.money.*）。如果你不希望指定具体类型的话，可以通过MonetaryAmountFactory来生成一个MonetaryAmount的实例:

  1. MonetaryAmount specAmount = MonetaryAmounts.getDefaultAmountFactory()
  2. .setNumber(123.45)
  3. .setCurrency("USD")
  4. .create();
复制代码

当且仅当实现类，货币单位，以及数值全部相等时才认为这两个MontetaryAmount实例是相等的。

  1. MonetaryAmount oneEuro = Money.of(1, MonetaryCurrencies.getCurrency("EUR"));
  2. boolean isEqual = oneEuro.equals(Money.of(1, "EUR")); // true
  3. boolean isEqualFast = oneEuro.equals(FastMoney.of(1, "EUR")); // false
复制代码

MonetaryAmount内包含丰富的方法，可以用来获取具体的货币，金额，精度等等：

  1. MonetaryAmount monetaryAmount = Money.of(123.45, euro);
  2. CurrencyUnit currency = monetaryAmount.getCurrency();
  3. NumberValue numberValue = monetaryAmount.getNumber();
  5. int intValue = numberValue.intValue(); // 123
  6. double doubleValue = numberValue.doubleValue(); // 123.45
  7. long fractionDenominator = numberValue.getAmountFractionDenominator(); // 100
  8. long fractionNumerator = numberValue.getAmountFractionNumerator(); // 45
  9. int precision = numberValue.getPrecision(); // 5
  11. // NumberValue extends java.lang.Number.
  12. // So we assign numberValue to a variable of type Number
  13. Number number = numberValue;
复制代码
MonetaryAmount的使用

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

  1. MonetaryAmount twelveEuro = fiveEuro.add(sevenEuro); // "EUR 12"
  2. MonetaryAmount twoEuro = sevenEuro.subtract(fiveEuro); // "EUR 2"
  3. MonetaryAmount sevenPointFiveEuro = fiveEuro.multiply(1.5); // "EUR 7.5"
  5. // MonetaryAmount can have a negative NumberValue
  6. MonetaryAmount minusTwoEuro = fiveEuro.subtract(sevenEuro); // "EUR -2"
  8. // some useful utility methods
  9. boolean greaterThan = sevenEuro.isGreaterThan(fiveEuro); // true
  10. boolean positive = sevenEuro.isPositive(); // true
  11. boolean zero = sevenEuro.isZero(); // false
  13. // Note that MonetaryAmounts need to have the same CurrencyUnit to do mathematical operations
  14. // this fails with: javax.money.MonetaryException: Currency mismatch: EUR/USD
  15. fiveEuro.add(tenUsDollar);
复制代码

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

  1. CurrencyUnit usd = MonetaryCurrencies.getCurrency("USD");
  2. MonetaryAmount dollars = Money.of(12.34567, usd);
  3. MonetaryOperator roundingOperator = MonetaryRoundings.getRounding(usd);
  4. MonetaryAmount roundedDollars = dollars.with(roundingOperator); // USD 12.35
复制代码

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

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

看一下下面这个集合：

  1. List<MonetaryAmount> amounts = new ArrayList<>();
  2. amounts.add(Money.of(2, "EUR"));
  3. amounts.add(Money.of(42, "USD"));
  4. amounts.add(Money.of(7, "USD"));
  5. amounts.add(Money.of(13.37, "JPY"));
  6. amounts.add(Money.of(18, "USD"));
复制代码

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

  1. CurrencyUnit yen = MonetaryCurrencies.getCurrency("JPY");
  2. CurrencyUnit dollar = MonetaryCurrencies.getCurrency("USD");
  5. // 根据货币过滤，只返回美金
  6. // result is [USD 18, USD 7, USD 42]
  7. List<MonetaryAmount> onlyDollar = amounts.stream()
  8. .filter(MonetaryFunctions.isCurrency(dollar))
  9. .collect(Collectors.toList());
  11. // 根据货币过滤，只返回美金和日元
  12. // [USD 18, USD 7, JPY 13.37, USD 42]
  13. List<MonetaryAmount> onlyDollarAndYen = amounts.stream()
  14. .filter(MonetaryFunctions.isCurrency(dollar, yen))
  15. .collect(Collectors.toList());
复制代码

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

  1. MonetaryAmount tenDollar = Money.of(10, dollar);
  3. // [USD 42, USD 18]
  4. List<MonetaryAmount> greaterThanTenDollar = amounts.stream()
  5. .filter(MonetaryFunctions.isCurrency(dollar))
  6. .filter(MonetaryFunctions.isGreaterThan(tenDollar))
  7. .collect(Collectors.toList());
复制代码

排序也是类似的：

  1. // Sorting dollar values by number value
  2. // [USD 7, USD 18, USD 42]
  3. List<MonetaryAmount> sortedByAmount = onlyDollar.stream()
  4. .sorted(MonetaryFunctions.sortNumber())
  5. .collect(Collectors.toList());
  7. // Sorting by CurrencyUnit
  8. // [EUR 2, JPY 13.37, USD 42, USD 7, USD 18]
  9. List<MonetaryAmount> sortedByCurrencyUnit = amounts.stream()
  10. .sorted(MonetaryFunctions.sortCurrencyUnit())
  11. .collect(Collectors.toList());
复制代码

还有分组操作：

  1. // 按货币单位进行分组
  2. // {USD=[USD 42, USD 7, USD 18], EUR=[EUR 2], JPY=[JPY 13.37]}
  3. Map<CurrencyUnit, List<MonetaryAmount>> groupedByCurrency = amounts.stream()
  4. .collect(MonetaryFunctions.groupByCurrencyUnit());
  6. // 分组并进行汇总
  7. Map<CurrencyUnit, MonetarySummaryStatistics> summary = amounts.stream()
  8. .collect(MonetaryFunctions.groupBySummarizingMonetary()).get();
  10. // get summary for CurrencyUnit USD
  11. MonetarySummaryStatistics dollarSummary = summary.get(dollar);
  12. MonetaryAmount average = dollarSummary.getAverage(); // "USD 22.333333333333333333.."
  13. MonetaryAmount min = dollarSummary.getMin(); // "USD 7"
  14. MonetaryAmount max = dollarSummary.getMax(); // "USD 42"
  15. MonetaryAmount sum = dollarSummary.getSum(); // "USD 67"
  16. long count = dollarSummary.getCount(); // 3
复制代码

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

  1. List<MonetaryAmount> amounts = new ArrayList<>();
  2. amounts.add(Money.of(10, "EUR"));
  3. amounts.add(Money.of(7.5, "EUR"));
  4. amounts.add(Money.of(12, "EUR"));
  6. Optional<MonetaryAmount> max = amounts.stream().reduce(MonetaryFunctions.max()); // "EUR 7.5"
  7. Optional<MonetaryAmount> min = amounts.stream().reduce(MonetaryFunctions.min()); // "EUR 12"
  8. Optional<MonetaryAmount> sum = amounts.stream().reduce(MonetaryFunctions.sum()); // "EUR 29.5"
复制代码
自定义的MonetaryAmount操作

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

  1. // A monetary operator that returns 10% of the input MonetaryAmount
  2. // Implemented using Java 8 Lambdas
  3. MonetaryOperator tenPercentOperator = (MonetaryAmount amount) -> {
  4. BigDecimal baseAmount = amount.getNumber().numberValue(BigDecimal.class);
  5. BigDecimal tenPercent = baseAmount.multiply(new BigDecimal("0.1"));
  6. return Money.of(tenPercent, amount.getCurrency());
  7. };
  9. MonetaryAmount dollars = Money.of(12.34567, "USD");
  11. // apply tenPercentOperator to MonetaryAmount
  12. 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）的汇率。

  1. // get the default ExchangeRateProvider (CompoundRateProvider)
  2. ExchangeRateProvider exchangeRateProvider = MonetaryConversions.getExchangeRateProvider();
  4. // get the names of the default provider chain
  5. // [IDENT, ECB, IMF, ECB-HIST]
  6. List<String> defaultProviderChain = MonetaryConversions.getDefaultProviderChain();
  8. // get a specific ExchangeRateProvider (here ECB)
  9. ExchangeRateProvider ecbExchangeRateProvider = MonetaryConversions.getExchangeRateProvider("ECB");
复制代码

如果没有指定ExchangeRateProvider的话返回的就是CompoundRateProvider。CompoundRateProvider会将汇率转换请求委派给一个ExchangeRateProvider链并将第一个返回准确结果的提供商的数据返回。

  1. // get the exchange rate from euro to us dollar
  2. ExchangeRate rate = exchangeRateProvider.getExchangeRate("EUR", "USD");
  4. NumberValue factor = rate.getFactor(); // 1.2537 (at time writing)
  5. CurrencyUnit baseCurrency = rate.getBaseCurrency(); // EUR
  6. CurrencyUnit targetCurrency = rate.getCurrency(); // USD
复制代码
货币转换

不同货币间的转换可以通过ExchangeRateProvider返回的CurrencyConversions来完成。

  1. // get the CurrencyConversion from the default provider chain
  2. CurrencyConversion dollarConversion = MonetaryConversions.getConversion("USD");
  4. // get the CurrencyConversion from a specific provider
  5. CurrencyConversion ecbDollarConversion = ecbExchangeRateProvider.getCurrencyConversion("USD");
  7. MonetaryAmount tenEuro = Money.of(10, "EUR");
  9. // convert 10 euro to us dollar
  10. MonetaryAmount inDollar = tenEuro.with(dollarConversion); // "USD 12.537" (at the time writing)
复制代码

请注意CurrencyConversion也实现了MonetaryOperator接口。正如其它操作一样，它也能通过MonetaryAmount.with()方法来调用。

格式化及解析

MonetaryAmount可以通过MonetaryAmountFormat来与字符串进行解析/格式化。

  1. // formatting by locale specific formats
  2. MonetaryAmountFormat germanFormat = MonetaryFormats.getAmountFormat(Locale.GERMANY);
  3. MonetaryAmountFormat usFormat = MonetaryFormats.getAmountFormat(Locale.CANADA);
  5. MonetaryAmount amount = Money.of(12345.67, "USD");
  7. String usFormatted = usFormat.format(amount); // "USD12,345.67"
  8. String germanFormatted = germanFormat.format(amount); // 12.345,67 USD
  10. // A MonetaryAmountFormat can also be used to parse MonetaryAmounts from strings
  11. MonetaryAmount parsed = germanFormat.parse("12,4 USD");
复制代码

可以通过AmountFormatQueryBuilder来生成自定义的格式。

  1. // Creating a custom MonetaryAmountFormat
  2. MonetaryAmountFormat customFormat = MonetaryFormats.getAmountFormat(
  3. AmountFormatQueryBuilder.of(Locale.US)
  4. .set(CurrencyStyle.NAME)
  5. .set("pattern", "00,00,00,00.00 ¤")
  6. .build());
  8. // results in "00,01,23,45.67 US Dollar"
  9. String formatted = customFormat.format(amount);
复制代码

注意，这里的¤符号在模式串中是作为货币的占位符。

总结

新的货币API这里已经介绍得差不多了。并且目前它的实现也已经相对稳定了（但还需要多补充些文档）。期待能在Java 9中看到这套新的接口!

上述示例可在Github中下载到。
收藏 邀请
上一篇：Java 注解Annotation下一篇：Java高效地读取一个大型文件

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-8 01:51

Copyright 2015-2025 djqfx

返回顶部