¿Cómo verificar que una cuerda sea parseable a un doble?

¿Existe alguna forma nativa (preferiblemente sin implementar su propio método) de verificar que una cadena sea analizable con Double.parseDouble() ?

El enfoque común sería verificarlo con una expresión regular como también se sugiere dentro de la documentación Double.valueOf(String) .

La expresión regular proporcionada allí (o incluida a continuación) debe abarcar todos los casos de coma flotante válidos, por lo que no es necesario que juegues con ella, ya que eventualmente perderás algunos de los puntos más finos.

Si no quiere hacer eso, try catch sigue siendo una opción.

La expresión regular sugerida por JavaDoc se incluye a continuación:

 final String Digits = "(\\p{Digit}+)"; final String HexDigits = "(\\p{XDigit}+)"; // an exponent is 'e' or 'E' followed by an optionally // signed decimal integer. final String Exp = "[eE][+-]?"+Digits; final String fpRegex = ("[\\x00-\\x20]*"+ // Optional leading "whitespace" "[+-]?(" + // Optional sign character "NaN|" + // "NaN" string "Infinity|" + // "Infinity" string // A decimal floating-point string representing a finite positive // number without a leading sign has at most five basic pieces: // Digits . Digits ExponentPart FloatTypeSuffix // // Since this method allows integer-only strings as input // in addition to strings of floating-point literals, the // two sub-patterns below are simplifications of the grammar // productions from the Java Language Specification, 2nd // edition, section 3.10.2. // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt "((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+ // . Digits ExponentPart_opt FloatTypeSuffix_opt "(\\.("+Digits+")("+Exp+")?)|"+ // Hexadecimal strings "((" + // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt "(0[xX]" + HexDigits + "(\\.)?)|" + // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" + ")[pP][+-]?" + Digits + "))" + "[fFdD]?))" + "[\\x00-\\x20]*");// Optional trailing "whitespace" if (Pattern.matches(fpRegex, myString)){ Double.valueOf(myString); // Will not throw NumberFormatException } else { // Perform suitable alternative action } 

Apache, como siempre, tiene una buena respuesta de Apache Commons-Lang en la forma de org.apache.commons.lang3.math.NumberUtils.isNumber(String)

Maneja nulos, no se requiere bloque try / catch .

Siempre puede ajustar Double.parseDouble () en un bloque try catch.

 try { Double.parseDouble(number); } catch(NumberFormatException e) { //not a double } 

Algo como abajo debería ser suficiente:

 String decimalPattern = "([0-9]*)\\.([0-9]*)"; String number="20.00"; boolean match = Pattern.matches(decimalPattern, number); System.out.println(match); //if true then decimal else not 

La biblioteca de Guava de Google proporciona un buen método de ayuda para hacer esto: Doubles.tryParse(String) . Lo usa como Double.parseDouble pero devuelve null lugar de arrojar una excepción si la cadena no se convierte en un doble.

Todas las respuestas están bien, dependiendo de cuán académica quieras ser. Si desea seguir las especificaciones de Java con precisión, use lo siguiente:

 private static final Pattern DOUBLE_PATTERN = Pattern.compile( "[\\x00-\\x20]*[+-]?(NaN|Infinity|((((\\p{Digit}+)(\\.)?((\\p{Digit}+)?)" + "([eE][+-]?(\\p{Digit}+))?)|(\\.((\\p{Digit}+))([eE][+-]?(\\p{Digit}+))?)|" + "(((0[xX](\\p{XDigit}+)(\\.)?)|(0[xX](\\p{XDigit}+)?(\\.)(\\p{XDigit}+)))" + "[pP][+-]?(\\p{Digit}+)))[fFdD]?))[\\x00-\\x20]*"); public static boolean isFloat(String s) { return DOUBLE_PATTERN.matcher(s).matches(); } 

Este código está basado en JavaDocs en Double .