在Java应用程序中用于金钱的最佳数据类型是什么？

Question

用于Java应用程序的最佳数据类型是什么？

Answer 1

Java有Currency类，它表示的ISO 4217货币代码。 BigDecimal是表示货币小数值的最佳类型。

Joda Money提供了一个库来代表金钱。

Answer 2

我会用Joda Money

它仍然在0.6的版本，但看起来非常有前途

Answer 3

BigDecimal要使用货币的最佳数据类型。

货币有很多容器，但它们都使用BigDecimal作为基础数据类型。 BigDecimal不会出错，可能使用BigDecimal.ROUND_HALF_EVEN四舍五入。

Answer 4

您应该使用的BigDecimal代表货币价值。它使您可以使用各种舍入模式，并在 金融应用，舍入模式往往是一个硬性要求 可能甚至受到法律的规定。

Answer 5

表示可能的最小值的整数类型。换句话说，你的程序应该以美分来计算，而不是以美元/欧元计算。

这不应该阻止你把gui翻译回美元/欧元。

Answer 6

BigDecimal可以用，为什么不使用浮点数或双精度可以在这里看到很好的解释：Why not use Double or Float to represent currency?

Answer 7

我喜欢使用Tiny Types，它会包含double，BigDecimal或int，如前面的答案所建议的。 （除非出现精度问题，否则我会使用双精度值）。

一个微小的类型给你类型安全，所以你不会把双重钱与其他双打混淆。

Answer 8

您可以使用货币和货币API（JSR 354）。此API预计将成为Java 9的一部分。如果您为项目添加适当的依赖关系，则可以在Java 7和Java 8中使用此API。

对于Java 8，作为一个依赖添加下面的参考实现您的pom.xml：

<dependency> 
    <groupId>org.javamoney</groupId> 
    <artifactId>moneta</artifactId> 
    <version>1.0</version> 
</dependency> 

这种依赖性将增加及物动词为javax.money:money-api依赖。

然后，您可以使用API​​：

package com.example.money; 

import static org.junit.Assert.assertThat; 
import static org.hamcrest.CoreMatchers.is; 

import java.util.Locale; 

import javax.money.Monetary; 
import javax.money.MonetaryAmount; 
import javax.money.MonetaryRounding; 
import javax.money.format.MonetaryAmountFormat; 
import javax.money.format.MonetaryFormats; 

import org.junit.Test; 

public class MoneyTest { 

    @Test 
    public void testMoneyApi() { 
     MonetaryAmount eurAmount1 = Monetary.getDefaultAmountFactory().setNumber(1.1111).setCurrency("EUR").create(); 
     MonetaryAmount eurAmount2 = Monetary.getDefaultAmountFactory().setNumber(1.1141).setCurrency("EUR").create(); 

     MonetaryAmount eurAmount3 = eurAmount1.add(eurAmount2); 
     assertThat(eurAmount3.toString(), is("EUR 2.2252")); 

     MonetaryRounding defaultRounding = Monetary.getDefaultRounding(); 
     MonetaryAmount eurAmount4 = eurAmount3.with(defaultRounding); 
     assertThat(eurAmount4.toString(), is("EUR 2.23")); 

     MonetaryAmountFormat germanFormat = MonetaryFormats.getAmountFormat(Locale.GERMAN); 
     assertThat(germanFormat.format(eurAmount4), is("EUR 2,23")); 


    } 
} 

Answer 9

我已经做了微基准（江铃控股）比较莫尼塔（Java JSR货币执行354）针对BigDecimal的在性能方面。

令人惊讶的是，BigDecimal的表现似乎比moneta更好。 我已经使用以下莫尼塔配置：

org.javamoney.moneta.Money.defaults.precision = 19 org.javamoney.moneta.Money.defaults.roundingMode = HALF_UP

package com.despegar.bookedia.money; 

import org.javamoney.moneta.FastMoney; 
import org.javamoney.moneta.Money; 
import org.openjdk.jmh.annotations.*; 

import java.math.BigDecimal; 
import java.math.MathContext; 
import java.math.RoundingMode; 
import java.util.concurrent.TimeUnit; 

@Measurement(batchSize = 5000, iterations = 10, time = 2, timeUnit =  TimeUnit.SECONDS) 
@Warmup(iterations = 2) 
@Threads(value = 1) 
@Fork(value = 1) 
@State(Scope.Benchmark) 
@BenchmarkMode(Mode.Throughput) 
public class BigDecimalBenchmark { 

private static final Money MONEY_BASE = Money.of(1234567.3444, "EUR"); 
private static final Money MONEY_SUBSTRACT = Money.of(232323, "EUR"); 
private static final FastMoney FAST_MONEY_SUBSTRACT = FastMoney.of(232323, "EUR"); 
private static final FastMoney FAST_MONEY_BASE = FastMoney.of(1234567.3444, "EUR"); 
MathContext mc = new MathContext(10, RoundingMode.HALF_UP); 

@Benchmark 
public void bigdecimal_string() { 
    new BigDecimal("1234567.3444").subtract(new BigDecimal("232323")).multiply(new BigDecimal("3.4"), mc).divide(new BigDecimal("5.456"), mc); 
} 

@Benchmark 
public void bigdecimal_valueOf() { 
    BigDecimal.valueOf(12345673444L, 4).subtract(BigDecimal.valueOf(232323L)).multiply(BigDecimal.valueOf(34, 1), mc).divide(BigDecimal.valueOf(5456, 3), mc); 
} 
@Benchmark 
public void fastmoney() { 
    FastMoney.of(1234567.3444, "EUR").subtract(FastMoney.of(232323, "EUR")).multiply(3.4).divide(5.456); 
} 

@Benchmark 
public void money() { 
    Money.of(1234567.3444, "EUR").subtract(Money.of(232323, "EUR")).multiply(3.4).divide(5.456); 
} 

@Benchmark 
public void money_static(){ 
    MONEY_BASE.subtract(MONEY_SUBSTRACT).multiply(3.4).divide(5.456); 
} 

@Benchmark 
public void fastmoney_static() { 
    FAST_MONEY_BASE.subtract(FAST_MONEY_SUBSTRACT).multiply(3.4).divide(5.456); 
    } 
} 

从而造成

钱：

Benchmark        Mode Cnt  Score Error Units 
BigDecimalBenchmark.bigdecimal_string thrpt 10 479.465 ± 26.821 ops/s 
BigDecimalBenchmark.bigdecimal_valueOf thrpt 10 1066.754 ± 40.997 ops/s 
BigDecimalBenchmark.fastmoney   thrpt 10 83.917 ± 4.612 ops/s 
BigDecimalBenchmark.fastmoney_static thrpt 10 504.676 ± 21.642 ops/s 
BigDecimalBenchmark.money    thrpt 10 59.897 ± 3.061 ops/s 
BigDecimalBenchmark.money_static  thrpt 10 184.767 ± 7.017 ops/s 

，如果我失去了一些东西

Answer 10

JSR 354，请随时指正和Currency API

JSR 354提供了一个用于使用货币和货币表示，运输和执行综合计算的API。你可以从这个链接下载：

JSR 354: Money and Currency API Download

该规范由以下几件事：

1. 处理E中的API。 G。货币量和货币
2. API来支持互换实现
3. 工厂创建的实现类的实例
4. 功能为货币金额计算，转换和格式化
5. 的Java API与金钱和货币，这是工作计划包含在Java 9中。
6. 所有规范类和接口都位于javax.money。*包中。

JSR 354的样品例子：金钱和货币API：

创建一个MonetaryAmount并打印到控制台的一个例子是这样的::

MonetaryAmountFactory<?> amountFactory = Monetary.getDefaultAmountFactory(); 
MonetaryAmount monetaryAmount = amountFactory.setCurrency(Monetary.getCurrency("EUR")).setNumber(12345.67).create(); 
MonetaryAmountFormat format = MonetaryFormats.getAmountFormat(Locale.getDefault()); 
System.out.println(format.format(monetaryAmount)); 

当使用参考实施API，必要的代码要简单得多：

MonetaryAmount monetaryAmount = Money.of(12345.67, "EUR"); 
MonetaryAmountFormat format = MonetaryFormats.getAmountFormat(Locale.getDefault()); 
System.out.println(format.format(monetaryAmount)); 

API还支持与MonetaryAmounts计算：

MonetaryAmount monetaryAmount = Money.of(12345.67, "EUR"); 
MonetaryAmount otherMonetaryAmount = monetaryAmount.divide(2).add(Money.of(5, "EUR")); 

CurrencyUnit和MONETARYAMOUNT

// getting CurrencyUnits by locale 
CurrencyUnit yen = MonetaryCurrencies.getCurrency(Locale.JAPAN); 
CurrencyUnit canadianDollar = MonetaryCurrencies.getCurrency(Locale.CANADA); 

MONETARYAMOUNT具有允许访问所分配的货币，数字量的各种方法，其精度和更：

MonetaryAmount monetaryAmount = Money.of(123.45, euro); 
CurrencyUnit currency = monetaryAmount.getCurrency(); 
NumberValue numberValue = monetaryAmount.getNumber(); 

int intValue = numberValue.intValue(); // 123 
double doubleValue = numberValue.doubleValue(); // 123.45 
long fractionDenominator = numberValue.getAmountFractionDenominator(); // 100 
long fractionNumerator = numberValue.getAmountFractionNumerator(); // 45 
int precision = numberValue.getPrecision(); // 5 

// NumberValue extends java.lang.Number. 
// So we assign numberValue to a variable of type Number 
Number number = numberValue; 

MonetaryAmounts可以使用舍入运算符四舍五入：

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 

使用MonetaryAmounts的集合时，可以使用一些很好的实用工具筛选，排序和分组方法。

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")); 

定制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 

资源：

Handling money and currencies in Java with JSR 354

Looking into the Java 9 Money and Currency API (JSR 354)

另请参见：JSR 354 - Currency and Money

Answer 11

对于简单情况（一种货币），这已经足够了Integer/Long。 以美分（......）或百分之一/分（以固定分隔线所需的任何精度）保留金额