Najlepszy sposób na parsowanieDouble z przecinkiem jako separatorem dziesiętnym?

Następujące powoduje Exception:

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

Czy istnieje lepszy sposób do analizowania "1,234"dostać 1.234niż: p = p.replaceAll(",",".");?

Użyj java.text.NumberFormat :

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

Możesz tego użyć (francuskie ustawienia regionalne mają ,separator dziesiętny)

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

Lub możesz użyć java.text.DecimalFormati ustawić odpowiednie symbole:

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

Jak wskazuje E-Riz, NumberFormat.parse (String) analizuje „1,23abc” jako 1,23. Aby wziąć cały wpis, możemy użyć:

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(',','.'))

... jest bardzo szybki, ponieważ przeszukuje podstawową tablicę znaków na podstawie znaków po znaku. Ciąg znaków zastępujących wersje kompiluje wyrażenie RegEx do oceny.

Zasadniczo funkcja replace (char, char) jest około 10 razy szybsza, a ponieważ będziesz robić tego typu rzeczy w kodzie niskiego poziomu, warto o tym pomyśleć. Optymalizator Hot Spot tego nie rozgryzie ... Na pewno nie w moim systemie.

Jeśli nie znasz prawidłowego ustawienia regionalnego, a ciąg znaków może mieć separator tysięcy, może to być ostateczność:

    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(",", "."));

Uwaga: to z przyjemnością przeanalizuje ciągi, takie jak „R 1 52.43,2” do „15243.2”.

Oto metoda statyczna, której używam w moim własnym kodzie:

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;
        }
    }
}

Oczywiście musisz użyć prawidłowego ustawienia regionalnego. To pytanie pomoże.

W przypadku, gdy nie znasz ustawień regionalnych otrzymanej wartości ciągu i niekoniecznie jest to to samo ustawienie regionalne, co bieżące domyślne ustawienie regionalne, możesz użyć tego:

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

}

Zwróci wartość double niezależnie od ustawień regionalnych łańcucha. I bez względu na to, ile jest przecinków lub punktów. Tak więc przekazywanie 1,000,000.54będzie działać, więc 1.000.000,54nie musisz już polegać na domyślnych ustawieniach regionalnych do analizowania ciągu. Kod nie jest tak zoptymalizowany, jak może być, więc wszelkie sugestie są mile widziane. Próbowałem przetestować większość przypadków, aby upewnić się, że rozwiązuje problem, ale nie jestem pewien, czy obejmuje wszystkie. Jeśli znajdziesz wartość zrywającą, daj mi znać.

To wystarczyłoby:

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