Bester Weg zum ParsenDoppeln mit Komma als Dezimaltrennzeichen?

Folgendes führt zu einem Exception:

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

Gibt es eine bessere Art und Weise zu analysieren , "1,234"zu erhalten 1.234als: p = p.replaceAll(",",".");?

Verwenden Sie java.text.NumberFormat :

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

Sie können dies verwenden (das französische Gebietsschema hat ein ,Dezimaltrennzeichen)

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

Oder Sie können java.text.DecimalFormatdie entsprechenden Symbole verwenden und einstellen:

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

Wie E-Riz hervorhebt, analysiert NumberFormat.parse (String) "1,23abc" als 1,23. Um die gesamte Eingabe zu übernehmen, können wir verwenden:

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

... ist sehr schnell, da es das zugrunde liegende Zeichenarray char-by-char durchsucht. Die Versionen zum Ersetzen von Zeichenfolgen kompilieren ein RegEx, das ausgewertet werden soll.

Grundsätzlich ist das Ersetzen (char, char) ungefähr zehnmal schneller und da Sie diese Art von Dingen in Low-Level-Code ausführen, ist es sinnvoll, darüber nachzudenken. Der Hot Spot-Optimierer wird es nicht herausfinden ... Auf meinem System sicherlich nicht.

Wenn Sie das richtige Gebietsschema nicht kennen und die Zeichenfolge tausend Trennzeichen haben kann, kann dies ein letzter Ausweg sein:

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

Beachten Sie: Dadurch werden Zeichenfolgen wie "R 1 52.43,2" bis "15243.2" gerne analysiert.

Dies ist die statische Methode, die ich in meinem eigenen Code verwende:

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

Sie müssen natürlich das richtige Gebietsschema verwenden. Diese Frage wird helfen.

In dem Fall, in dem Sie das Gebietsschema des empfangenen Zeichenfolgenwerts nicht kennen und es nicht unbedingt dasselbe Gebietsschema wie das aktuelle Standardgebietsschema ist, können Sie Folgendes verwenden:

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

}

Es wird ein Double zurückgegeben, unabhängig vom Gebietsschema der Zeichenfolge. Und egal wie viele Kommas oder Punkte es gibt. Das Übergeben 1,000,000.54funktioniert also auch, 1.000.000,54sodass Sie sich beim Parsen der Zeichenfolge nicht mehr auf das Standardgebietsschema verlassen müssen. Der Code ist nicht so optimiert wie er sein kann, daher sind Vorschläge willkommen. Ich habe versucht, die meisten Fälle zu testen, um sicherzustellen, dass das Problem dadurch gelöst wird, aber ich bin nicht sicher, ob es alles abdeckt. Wenn Sie einen Bruchwert finden, lassen Sie es mich wissen.

Dies würde den Job machen:

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