Wie überprüft man, ob eine Zeichenkette zu einem Double zerlegbar ist?

Gibt es einen nativen Weg (vorzugsweise ohne eigene Methode zu implementieren), um zu überprüfen, ob eine Zeichenkette mit Double.parseDouble() ?

   

Der übliche Ansatz wäre, es mit einem regulären Ausdruck zu überprüfen, wie es auch in der Double.valueOf(String) -Dokumentation vorgeschlagen wird.

Der dort bereitgestellte Regexp (oder darunter enthalten) sollte alle gültigen Gleitkomma-Fälle abdecken, so dass Sie nicht damit herumspielen müssen, da Sie schließlich einige der feineren Punkte verpassen werden.

Wenn Sie das nicht tun wollen, try catch ist immer noch eine Option.

Der von JavaDoc vorgeschlagene Regexp ist unten enthalten:

 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 hat wie üblich eine gute Antwort von Apache Commons-Lang in Form von org.apache.commons.lang3.math.NumberUtils.isNumber(String)

Handles Nullen, kein try / catch Block erforderlich.

Sie können Double.parseDouble () immer in einen try-catch-Block umbrechen.

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

Etwas wie unten sollte ausreichen: –

 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 

Googles Guava-Bibliothek bietet dazu eine nette Doubles.tryParse(String) : Doubles.tryParse(String) . Sie verwenden es wie Double.parseDouble aber es gibt Double.parseDouble zurück, anstatt eine Ausnahme Double.parseDouble , wenn die Zeichenfolge nicht zu einem Doppelklick verarbeitet wird.

Alle Antworten sind OK, abhängig davon, wie akademisch du sein möchtest. Wenn Sie den Java-Spezifikationen genau folgen möchten, verwenden Sie Folgendes:

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

Dieser Code basiert auf den JavaDocs bei Double .