La meilleure façon de parseDouble avec virgule comme séparateur décimal?

vous pouvez utiliser ceci (LA locale FRANÇAISE a , pour le séparateur décimal)

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

ou vous pouvez utiliser java.text.DecimalFormat et placer les symboles appropriés:

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

comme E-Riz le souligne, NumberFormat.parse(String) analyser "1,23 abc" comme 1.23. Pour prendre l'entrée entière 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();
}

si vous ne connaissez pas la bonne localisation et que la chaîne peut avoir mille séparateurs, cela pourrait ê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(",", "."));

soyez conscient: cela analysera volontiers des cordes 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 ...
        ///q/best-way-to-parsedouble-with-comma-as-decimal-separator-69285/",",".");

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

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

... est très rapide car il recherche le tableau de caractères sous-jacent sur une base char-by-char. La chaîne replace versions compilent un RegEx pour évaluer.

remplacer(char,char) est environ 10 fois plus rapide et depuis que vous ferez ce genre de choses dans le code de bas niveau, il est logique de penser à cela. L'optimiseur de points chauds ne le comprendra pas... Certainement pas dans mon système.

vous devez bien sûr utiliser le bon emplacement. Ce la question de l'aide.

Ce serait faire le travail:

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