यह जांचने के लिए कि एक स्ट्रिंग एक डबल के लिए पारदर्शी है?

Question

क्या कोई स्ट्रिंग Double.parseDouble() के साथ पर्स करने योग्य है यह जांचने के लिए कोई मूल तरीका है (अधिमानतः अपनी विधि को कार्यान्वित किए बिना)?

Answer 1

आम तरीका एक नियमित अभिव्यक्ति के साथ यह जाँच करने के लिए की तरह यह भी Double.valueOf(String) प्रलेखन के अंदर सुझाव दिया है किया जाएगा।

वहां प्रदान किए गए रेगेक्सप (या नीचे शामिल) में सभी मान्य फ़्लोटिंग पॉइंट मामलों को शामिल करना चाहिए, इसलिए आपको इसके साथ परेशान करने की आवश्यकता नहीं है, क्योंकि आप अंततः कुछ बेहतर बिंदुओं पर ध्यान नहीं देंगे।

यदि आप ऐसा नहीं करना चाहते हैं, तो try catch अभी भी एक विकल्प है।

regexp JavaDoc ने सुझाव दिया नीचे शामिल है:

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 
} 

Answer 2

आप हमेशा कोशिश करें ब्लॉक में Double.parseDouble() को लपेट सकते हैं।

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

Answer 3

कुछ नीचे की तरह पर्याप्त होना चाहिए: -

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 

Answer 4

अपाचे, हमेशा की तरह, के रूप में Apache Commons-Lang से एक अच्छा जवाब है org.apache.commons.lang3.math.NumberUtils.isNumber(String)

नल को संभालता है, try/catch ब्लॉक आवश्यक है।

Answer 5

सभी उत्तरों ठीक हैं, इस पर निर्भर करता है कि आप कैसे अकादमिक होना चाहते हैं।

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

इस कोड Double पर Javadocs पर आधारित है: आप सही रूप में जावा विनिर्देशों का पालन करना चाहते हैं, तो निम्न का उपयोग करें।

Answer 6

Google की गुवा लाइब्रेरी ऐसा करने के लिए एक अच्छी सहायक विधि प्रदान करती है: Doubles.tryParse(String)। आप इसे Double.parseDouble जैसे उपयोग करते हैं, लेकिन यदि स्ट्रिंग दो बार नहीं पाती है तो अपवाद फेंकने के बजाय यह null लौटाता है।