How to check if a string contains only digits in Java


String regex = "[0-9]+";


String regex = "\\d+";

As per Java regular expressions, the + means “one or more times” and \d means “a digit”.

Note: the “double backslash” is an escape sequence to get a single backslash – therefore, \\d in a java String gives you the actual result: \d


Java Regular Expressions

Java Character Escape Sequences

Edit: due to some confusion in other answers, I am writing a test case and will explain some more things in detail.

Firstly, if you are in doubt about the correctness of this solution (or others), please run this test case:

String regex = "\\d+";

// positive test cases, should all be "true"

// negative test cases, should all be "false"

Question 1: Isn’t it necessary to add ^ and $ to the regex, so it won’t match “aa123bb” ?

No. In java, the matches method (which was specified in the question) matches a complete string, not fragments. In other words, it is not necessary to use ^\\d+$ (even though it is also correct). Please see the last negative test case.

Please note that if you use an online “regex checker” then this may behave differently. To match fragments of a string in Java, you can use the find method instead, described in detail here:

Difference between matches() and find() in Java Regex

Question 2: Won’t this regex also match the empty string, "" ?

No. A regex \\d* would match the empty string, but \\d+ does not. The star * means zero or more, whereas the plus + means one or more. Please see the first negative test case.

Question 3: Isn’t it faster to compile a regex Pattern?

Yes. It is indeed faster to compile a regex Pattern once, rather than on every invocation of matches, and so if performance implications are important then a Pattern can be compiled and used like this:

Pattern pattern = Pattern.compile(regex);



This is generally done with a simple user-defined function (i.e. Roll-your-own “isNumeric” function).

Something like:

public static boolean isNumeric(String str)  
    double d = Double.parseDouble(str);  
  catch(NumberFormatException nfe)  
    return false;  
  return true;  

However, if you’re calling this function a lot, and you expect many of the checks to fail due to not being a number then performance of this mechanism will not be great, since you’re relying upon exceptions being thrown for each failure, which is a fairly expensive operation.

An alternative approach may be to use a regular expression to check for validity of being a number:

public static boolean isNumeric(String str)
  return str.matches("-?\\d+(\\.\\d+)?");  //match a number with optional '-' and decimal.

Be careful with the above RegEx mechanism, though, as it’ll fail if you’re using non-arabic digits (i.e. numerals other than 0 through to 9). This is because the “\d” part of the RegEx will only match [0-9] and effectively isn’t internationally numerically aware. (Thanks to OregonGhost for pointing this out!)

Or even another alternative is to use Java’s built-in java.text.NumberFormat object to see if, after parsing the string the parser position is at the end of the string. If it is, we can assume the entire string is numeric:

public static boolean isNumeric(String str)
  NumberFormat formatter = NumberFormat.getInstance();
  ParsePosition pos = new ParsePosition(0);
  formatter.parse(str, pos);
  return str.length() == pos.getIndex();



你的電子郵件位址並不會被公開。 必要欄位標記為 *