Java中的货币转换器存在精度和压缩问题

Question

我得到了一份用Java编写的作业。

我们将开发一个货币转换应用程序，询问他们转换的货币、所述货币的数量以及他们希望转换的货币。

该指令指出，我们应该包括4种货币转换从/到。

我很早就完成了作业，我去给教授看，她注意到了一些问题。她喜欢代码的组织性和清晰性，但她认为我可以把它缩小一点，并用十进制精度解决我的问题。

关于把它缩短，她的主要论点是，我有7个常数，用来保持汇率。我对此感到非常自豪，因为对于每种可能的组合，7种价格都比12种单独价格短得多。代码如下。

// Conversion Rates - START (as of October 14, 2018 @ 1:03 AM)
// Rates obtained from exchange-rates.org
private final double USD_TO_USD = 1;

//Convert to United States Dollars
private final double CAD_TO_USD = 0.76792;
private final double EUR_TO_USD = 1.1407;
private final double YEN_TO_USD = 0.008923;

//Convert from United States Dollars
private final double USD_TO_CAD = 1.3022;
private final double USD_TO_EUR = 0.87662;
private final double USD_TO_YEN = 112.06;
// Conversion Rates - END

在我的方法背后，我的思维过程是将所有东西转换成美元，然后从美元转换成目标货币。我不确定如何进一步浓缩这一点，因此这是我面临的问题之一。

我遇到的主要问题是精确性。由于该课程主要基于商业数学，因此这些程序通常用于转换数百万/数十亿的货币。我知道double在精度方面已经有了自己的继承问题，但我不确定要使用哪些其他数据类型。我遇到了BigDecimal，我将在发布本文后对此进行研究。

据我所知，汇率中小数点的数量将直接影响结果的精度。汇率右边的数字越多越好。我是否应该养成包括大量小数点的习惯，使其很难出现精度问题？或者使用BigDecimal通常会解决这个问题。

我已经考虑过不再使用double，而是使用int；我会有一个双精度的整数，而不是一个双精度的整数；但在这一点上，我不确定“正确”的方式进行。

所以我来问你们这些好人：D

我很高兴能学到尽可能多的东西，所以任何帮助都很感激。

谢谢

更新：我花了一些时间检查BigDecimal，我让它工作了；但我现在的测试量从1到10不等（在非常大的数字中可能会更多，但我没有用不同的数字测试超过5次）。

在我的测试中，我将98765432.00日元兑换成美元，兑换率为1日元=0.008907美元。根据我当时用来核实的网站——以美元计算的结果应该是879701.24美元；但我的项目得到了879703.70美元。甚至我的科学计算器也得到了与java程序相同的结果。

Answer 1

下面是另一个实现：

给出如下货币汇率列表：

USD/GBP => 0.75 
GBP/AUD => 1.7 
AUD/JPY => 90 
GBP/JPY => 150 
JPY/INR => 0.6

Write a method

double convert(String sourceCurrency, double amount, String destCurrency);

==============

package test;

import java.util.*;

public class CurrencyConvertor {
    private Map<String, Map<String, Double>> mapping = new HashMap<String, Map<String, Double>>();
    private boolean bInit = false;
    private boolean bFound = false;

    double convert(String src, double amount, String dst) throws Exception {
        if (src.equals(dst))
            return amount;

        if (!bInit) {
            init();
            bInit = true;
        }

        bFound = false;
        if (mapping.get(src) == null) {
            throw new Exception("Invalid conversion");
        }

        List<String> visited = new ArrayList<String>();
        visited.add(src);
        double d1 = getRate(visited, src, dst, 1);
        if (bFound)
            return d1 * amount;
        throw new Exception("No mapping invalid conversion");
    }

    private double getRate(List<String> visited, String src, String dst, double rate) throws Exception {
        if (bFound == true) {
            return rate;
        }

        if (mapping.get(src).get(dst) != null) {
            bFound = true;
            return rate * mapping.get(src).get(dst);
        }

        double origRate = rate;
        for (String sInt : mapping.get(src).keySet()) {
            if (visited.contains(sInt)) {
                continue;
            }
            visited.add(sInt);
            rate = getRate(visited, sInt, dst, rate * mapping.get(src).get(sInt));
            if (bFound == true) {
                return rate;
            }
            visited.remove(sInt);
            rate = origRate;
        }

        return origRate;
    }

    private void init() {
        // Invalid case data, EUR to INR
        insert("EUR", "USD", 1.2);
        insert("USD", "EUR", 0.75);
        insert("YEN", "INR", 1.2);
        insert("INR", "YEN", 0.75);

        // Valid case data, EUR to INR
        // insert("EUR", "USD", 1.2);
        // insert("USD", "GBP", 0.75);
        // insert("GBP", "AUD", 1.7);
        // insert("AUD", "JPY", 90);
        // insert("GBP", "JPY", 150);
        // insert("JPY", "INR", 0.6);
        //
        // insert("USD", "EUR", 1.0/1.2);
        // insert("GBP", "USD", 1.0/0.75);
        // insert("AUD", "GBP", 1.0/1.7);
        // insert("JPY", "AUD", 1.0/90);
        // insert("JPY", "GBP", 1.0/150);
        // insert("INR", "JPY", 1.0/0.6);
    }

    private void insert(String src, String dst, double rate) {
        if (mapping.get(src) == null) {
            Map<String, Double> map = new HashMap<String, Double>();
            map.put(dst, rate);
            mapping.put(src, map);
        } else if (mapping.get(src).get(dst) == null) {
            mapping.get(src).put(dst, rate);
        }
    }

    public static void main(String args[]) {
        try {
            double d = new CurrencyConvertor().convert("EUR", 100, "INR");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Answer 2

只要继续使用BigDecimal实现的方法，就像使用BigDecimal一样，你不会失去任何精度，但是使用两倍，当你处理较大的数字时，就有可能失去精度。

请通过下面的stackoverflow链接了解关于BigDecimal的更多信息：Double vs.BigDecimal？

你在正确的轨道上，继续摇摆，快乐地学习。