You can also use NumberUtil.isNumber(String str) from Apache Commons

Using regular expressions is costly in terms of performance. Trying to parse string as a long value is inefficient and unreliable, and may be not what you need.

What I suggest is to simply check if each character is a digit, what can be efficiently done using Java 8 lambda expressions:

boolean isNumeric = someString.chars().allMatch(x -> Character.isDigit(x));

One more solution, that hasn't been posted, yet:

String regex = "\\p{Digit}+"; // uses POSIX character class

You must allow for more than a digit (the + sign) as in:

String regex = "[0-9]+"; 
String data = "23343453"; 
System.out.println(data.matches(regex));

Long.parseLong(data)

and catch exception, it handles minus sign.

Although the number of digits is limited this actually creates a variable of the data which can be used, which is, I would imagine, the most common use-case.

We can use either Pattern.compile("[0-9]+.[0-9]+") or Pattern.compile("\\d+.\\d+"). They have the same meaning.

the pattern [0-9] means digit. The same as '\d'. '+' means it appears more times. '.' for integer or float.

Try following code:

import java.util.regex.Pattern;

    public class PatternSample {

        public boolean containNumbersOnly(String source){
            boolean result = false;
            Pattern pattern = Pattern.compile("[0-9]+.[0-9]+"); //correct pattern for both float and integer.
            pattern = Pattern.compile("\\d+.\\d+"); //correct pattern for both float and integer.

            result = pattern.matcher(source).matches();
            if(result){
                System.out.println("\"" + source + "\""  + " is a number");
            }else
                System.out.println("\"" + source + "\""  + " is a String");
            return result;
        }

        public static void main(String[] args){
            PatternSample obj = new PatternSample();
            obj.containNumbersOnly("123456.a");
            obj.containNumbersOnly("123456 ");
            obj.containNumbersOnly("123456");
            obj.containNumbersOnly("0123456.0");
            obj.containNumbersOnly("0123456a.0");
        }

    }

Output:

"123456.a" is a String
"123456 " is a String
"123456" is a number
"0123456.0" is a number
"0123456a.0" is a String

According to Oracle's Java Documentation:

private static final Pattern NUMBER_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]*");
boolean isNumber(String s){
return NUMBER_PATTERN.matcher(s).matches()
}

Refer to org.apache.commons.lang3.StringUtils

    public static boolean isNumeric(CharSequence cs) {
        if (cs == null || cs.length() == 0) {
            return false;
        } else {
            int sz = cs.length();

            for(int i = 0; i < sz; ++i) {
                if (!Character.isDigit(cs.charAt(i))) {
                    return false;
                }
            }

            return true;
        }
    }

In Java for String class, there is a method called matches(). With help of this method you can validate the regex expression along with your string.

String regex = "^[\\d]{4}$";
   
String value = "1234";

System.out.println(data.matches(value));

The Explanation for the above regex expression is:-

• ^ - Indicates the start of the regex expression.

• [] - Inside this you have to describe your own conditions.

• \\\d - Only allows digits. You can use '\\d'or 0-9 inside the bracket both are same.

• {4} - This condition allows exactly 4 digits. You can change the number according to your need.

• $ - Indicates the end of the regex expression.

Note: You can remove the {4} and specify + which means one or more times, or * which means zero or more times, or ? which means once or none.

For more reference please go through this website: https://www.rexegg.com/regex-quickstart.html

To account for other digits beside Latin/English (aka Western Arabic digits):

var regex = "\\p{javaDigit}+"; // Same as "\\p{Nd}+"
"1234۱۲۳۴".matches(regex); // true

For Kotlin:

"1234۱۲۳۴".all(Char::isDigit) // true
// OR
"1234۱۲۳۴" matches Regex("\\p{javaDigit}") // Same as "\\p{Nd}"

Try this part of code:

void containsOnlyNumbers(String str)
{
    try {
        Integer num = Integer.valueOf(str);
        System.out.println("is a number");
    } catch (NumberFormatException e) {
        // TODO: handle exception
        System.out.println("is not a number");
    }

}

Offical regex way

I would use this regex for integers:

^[-1-9]\d*$

This will also work in other programming languages because it's more specific and doesn't make any assumptions about how different programming languages may interpret or handle regex.

Also works in Java

\\d+

Questions regarding ^ and $

As @vikingsteve has pointed out in java, the matches method matches a complete string, not parts of a string. In other words, it is unnecessary to use ^\d+$ (even though it is the official way of regex).

Online regex checkers are more strict and therefore they will behave differently than how Java handles regex.