Meilleur moyen d'analyserDouble avec une virgule comme séparateur décimal?

Ce qui suit entraîne un Exception:

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

Existe-t-il un meilleur moyen d'analyser "1,234"pour obtenir 1.234que p = p.replaceAll(",",".");:?

Utilisez java.text.NumberFormat :

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

Vous pouvez utiliser ceci (la langue française a ,pour séparateur décimal)

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

Ou vous pouvez utiliser java.text.DecimalFormatet définir les symboles appropriés:

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

Comme le souligne E-Riz, NumberFormat.parse (String) analyse "1,23abc" comme étant 1.23. Pour prendre toute l'entrée, nous pouvons utiliser:

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

... est très rapide car il recherche le tableau de caractères sous-jacent caractère par caractère. La chaîne remplace les versions compilent un RegEx à évaluer.

En gros, replace (char, char) est environ 10 fois plus rapide et puisque vous ferez ce genre de choses dans un code de bas niveau, il est logique d'y penser. L'optimiseur Hot Spot ne le comprendra pas ... Certainement pas sur mon système.

Si vous ne connaissez pas les paramètres régionaux corrects et que la chaîne peut avoir un séparateur de milliers, cela peut être un dernier recours:

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

Attention: cela analysera volontiers des chaînes comme "R 1 52.43,2" à "15243.2".

C'est la méthode statique que j'utilise dans mon propre code:

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

Vous devez bien sûr utiliser les paramètres régionaux appropriés. Cette question aidera.

Dans le cas où vous ne connaissez pas les paramètres régionaux de la valeur de chaîne reçue et qu'il ne s'agit pas nécessairement des mêmes paramètres régionaux que les paramètres régionaux par défaut actuels, vous pouvez utiliser ceci:

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

}

Il renverra un double quelle que soit la locale de la chaîne. Et peu importe le nombre de virgules ou de points. Le passage 1,000,000.54fonctionnera donc, 1.000.000,54vous n'aurez plus à vous fier aux paramètres régionaux par défaut pour analyser la chaîne. Le code n'est pas aussi optimisé qu'il peut l'être, toutes les suggestions sont donc les bienvenues. J'ai essayé de tester la plupart des cas pour m'assurer que cela résout le problème, mais je ne suis pas sûr que cela couvre tous. Si vous trouvez une valeur de rupture, faites-le moi savoir.

Cela ferait le travail:

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