public boolean isANumber(String s) {
    try {
        BigDecimal a = new BigDecimal(s);
        return true;
    } catch (NumberFormatException e) {
        return false;
    }
}

isNumber[1]

public static boolean isNumber(java.lang.String str)
Checks whether the String a valid Java number.

Valid numbers include hexadecimal marked with the 0x qualifier, scientific notation and numbers marked with a type qualifier (e.g. 123L).

Null and empty String will return false.

Parameters:
str - the String to check
Returns:
true if the string is a correctly formatted number

public class TestRegexp {
    static final String NUM_REGEX=
        "-?((([0-9]{1,3})(,[0-9]{3})*)|[0-9]*)(\.[0-9]+)?([Ee][0-9]*)?";
    public static boolean isNum(String s) {
        	return s!=null && s.length()>0 && s.matches(NUM_REGEX);
    }
    public static void main(String[]args) {
    	String[] values={
    			"",
    			"0",
    			"0.1",
    			".1",
    			"-.5E5",
    			"-12,524.5E5",
    			"-452,456,456,466.5E5",
    			"-452,456,456,466E5",
    			"22,22,2.14123415e1",
    	};
    	for (String value : values) {
    		System.out.println(value+" is a number: "
			+isNum(value));
    	}
    }

}

"-?(([0-9]{1,3}(,[0-9{3,3})*)|[0-9]*)(.[0-9]+(e-?[0-9]*)?)?"

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
}