用逗号作为小数点分隔符来解析Double的最佳方法？

以下结果是Exception：

String p="1,234";
Double d=Double.valueOf(p); 
System.out.println(d);

有没有更好的方法来分析"1,234"，以得到1.234比：p = p.replaceAll(",",".");？

使用java.text.NumberFormat：

NumberFormat format = NumberFormat.getInstance(Locale.FRANCE);
Number number = format.parse("1,234");
double d = number.doubleValue();

您可以使用它（法语语言环境具有,小数点分隔符）

NumberFormat nf = NumberFormat.getInstance(Locale.FRANCE);
nf.parse(p);

或者，您可以使用java.text.DecimalFormat并设置适当的符号：

DecimalFormat df = new DecimalFormat();
DecimalFormatSymbols symbols = new DecimalFormatSymbols();
symbols.setDecimalSeparator(',');
symbols.setGroupingSeparator(' ');
df.setDecimalFormatSymbols(symbols);
df.parse(p);

正如E-Riz所指出的，NumberFormat.parse（String）将“ 1,23abc”解析为1.23。要获取全部输入，我们可以使用：

public double parseDecimal(String input) throws ParseException{
  NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.getDefault());
  ParsePosition parsePosition = new ParsePosition(0);
  Number number = numberFormat.parse(input, parsePosition);

  if(parsePosition.getIndex() != input.length()){
    throw new ParseException("Invalid input", parsePosition.getIndex());
  }

  return number.doubleValue();
}

Double.parseDouble(p.replace(',','.'))

...非常快，因为它逐个字符地搜索基础字符数组。字符串替换版本会编译RegEx进行评估。

基本上，replace（char，char）大约快10倍，并且由于您将在低级代码中执行此类操作，因此考虑一下是有意义的。热点优化器将无法解决...当然不在我的系统上。

如果您不知道正确的语言环境，并且字符串可以有千位分隔符，那么这可能是最后的选择：

    doubleStrIn = doubleStrIn.replaceAll("[^\\d,\\.]++", "");
    if (doubleStrIn.matches(".+\\.\\d+,\\d+$"))
        return Double.parseDouble(doubleStrIn.replaceAll("\\.", "").replaceAll(",", "."));
    if (doubleStrIn.matches(".+,\\d+\\.\\d+$"))
        return Double.parseDouble(doubleStrIn.replaceAll(",", ""));
    return Double.parseDouble(doubleStrIn.replaceAll(",", "."));

请注意：这将很高兴地将字符串解析为“ R 1 52.43,2”至“ 15243.2”。

这是我在自己的代码中使用的静态方法：

public static double sGetDecimalStringAnyLocaleAsDouble (String value) {

    if (value == null) {
        Log.e("CORE", "Null value!");
        return 0.0;
    }

    Locale theLocale = Locale.getDefault();
    NumberFormat numberFormat = DecimalFormat.getInstance(theLocale);
    Number theNumber;
    try {
        theNumber = numberFormat.parse(value);
        return theNumber.doubleValue();
    } catch (ParseException e) {
        // The string value might be either 99.99 or 99,99, depending on Locale.
        // We can deal with this safely, by forcing to be a point for the decimal separator, and then using Double.valueOf ...
        //http://stackoverflow.com/questions/4323599/best-way-to-parsedouble-with-comma-as-decimal-separator
        String valueWithDot = value.replaceAll(",",".");

        try {
          return Double.valueOf(valueWithDot);
        } catch (NumberFormatException e2)  {
            // This happens if we're trying (say) to parse a string that isn't a number, as though it were a number!
            // If this happens, it should only be due to application logic problems.
            // In this case, the safest thing to do is return 0, having first fired-off a log warning.
            Log.w("CORE", "Warning: Value is not a number" + value);
            return 0.0;
        }
    }
}

您当然需要使用正确的语言环境。这个问题会有所帮助。

如果您不知道接收到的字符串值的语言环境，并且该语言环境不一定与当前的默认语言环境相同，则可以使用以下方法：

private static double parseDouble(String price){
    String parsedStringDouble;
    if (price.contains(",") && price.contains(".")){
        int indexOfComma = price.indexOf(",");
        int indexOfDot = price.indexOf(".");
        String beforeDigitSeparator;
        String afterDigitSeparator;
        if (indexOfComma < indexOfDot){
            String[] splittedNumber = price.split("\\.");
            beforeDigitSeparator = splittedNumber[0];
            afterDigitSeparator = splittedNumber[1];
        }
        else {
            String[] splittedNumber = price.split(",");
            beforeDigitSeparator = splittedNumber[0];
            afterDigitSeparator = splittedNumber[1];
        }
        beforeDigitSeparator = beforeDigitSeparator.replace(",", "").replace(".", "");
        parsedStringDouble = beforeDigitSeparator+"."+afterDigitSeparator;
    }
    else {
        parsedStringDouble = price.replace(",", "");
    }

    return Double.parseDouble(parsedStringDouble);

}

无论字符串的语言环境是什么，它都会返回一个double值。而且无论有多少逗号或要点。因此，传递1,000,000.54将起作用，1.000.000,54因此您不必再依赖默认语言环境来解析字符串。该代码没有得到最佳优化，因此欢迎您提出任何建议。我试图测试大多数情况，以确保它可以解决问题，但是我不确定它是否涵盖所有问题。如果您发现突破性的价值，请告诉我。

这将完成工作：

Double.parseDouble(p.replace(',','.'));