Il modo migliore per analizzare Doppio con virgola come separatore decimale?

Di seguito si ottiene un Exception:

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

C'è un modo migliore per analizzare "1,234"per ottenere 1.234di p = p.replaceAll(",",".");:?

Usa java.text.NumberFormat :

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

Puoi usarlo (la locale francese ha ,come separatore decimale)

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

Oppure puoi usare java.text.DecimalFormate impostare i simboli appropriati:

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

Come sottolinea E-Riz, NumberFormat.parse (String) analizza "1,23abc" come 1,23. Per prendere l'intero input possiamo usare:

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

... è molto veloce in quanto cerca l'array di caratteri sottostante su base char-by-char. Le versioni di sostituzione stringa compilano un RegEx da valutare.

Sostanzialmente sostituire (char, char) è circa 10 volte più veloce e dato che farai questo tipo di cose nel codice di basso livello ha senso pensarci. L'ottimizzatore Hot Spot non lo capirà ... Certamente no sul mio sistema.

Se non conosci le impostazioni internazionali corrette e la stringa può avere un migliaio di separatori, questa potrebbe essere l'ultima risorsa:

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

Attenzione: questo analizzerà felicemente stringhe come "R 1 52.43,2" a "15243.2".

Questo è il metodo statico che uso nel mio codice:

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

Ovviamente devi usare le impostazioni locali corrette. Questa domanda sarà di aiuto.

Nel caso in cui non si conosca la locale del valore della stringa ricevuta e non sia necessariamente la stessa locale della locale predefinita corrente, è possibile utilizzare questo:

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

}

Restituirà un doppio, qualunque sia la locale della stringa. E non importa quante virgole o punti ci siano. Quindi il passaggio 1,000,000.54funzionerà, 1.000.000,54quindi non dovrai più fare affidamento sulla locale predefinita per analizzare la stringa. Il codice non è ottimizzato come può essere, quindi qualsiasi suggerimento è il benvenuto. Ho provato a testare la maggior parte dei casi per assicurarmi che risolva il problema, ma non sono sicuro che copra tutto. Se trovi un valore di rottura fammelo sapere.

Questo farebbe il lavoro:

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