La mejor manera de analizar ¿Doble con una coma como separador decimal?

Lo siguiente resulta en un Exception:

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

¿Hay una mejor manera de analizar "1,234"para obtener 1.234que p = p.replaceAll(",",".");:?

Utilice java.text.NumberFormat :

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

Puede usar esto (la configuración regional en francés tiene ,un separador decimal)

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

O puede usar java.text.DecimalFormaty establecer los símbolos apropiados:

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

Como señala E-Riz, NumberFormat.parse (String) analiza "1,23abc" como 1,23. Para tomar toda la entrada podemos usar:

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

... es muy rápido, ya que busca en la matriz de caracteres subyacente char-by-char. Las versiones de reemplazo de cadenas compilan un RegEx para evaluar.

Básicamente, reemplazar (char, char) es aproximadamente 10 veces más rápido y dado que harás este tipo de cosas en código de bajo nivel, tiene sentido pensar en esto. El optimizador de Hot Spot no lo resolverá ... Ciertamente no lo hace en mi sistema.

Si no conoce la configuración regional correcta y la cadena puede tener mil separadores, este podría ser el último recurso:

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

Tenga en cuenta: esto felizmente analizará cadenas como "R 1 52.43,2" a "15243.2".

Este es el método estático que uso en mi propio código:

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

Por supuesto, debe usar la configuración regional correcta. Esta pregunta te ayudará.

En el caso de que no conozca la configuración regional del valor de cadena recibido y no sea necesariamente la misma configuración regional que la configuración regional predeterminada actual, puede usar esto:

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

}

Devolverá un doble sin importar cuál sea la configuración regional de la cadena. Y no importa cuántas comas o puntos haya. Por lo tanto, pasar 1,000,000.54funcionará, 1.000.000,54así que no tendrá que depender de la configuración regional predeterminada para analizar la cadena más. El código no está tan optimizado como puede ser, por lo que cualquier sugerencia es bienvenida. Traté de probar la mayoría de los casos para asegurarme de que resuelve el problema, pero no estoy seguro de que cubra todos. Si encuentra un valor de ruptura, hágamelo saber.

Esto haría el trabajo:

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