Pattern p = Pattern.compile("-?\\d+");
Matcher m = p.matcher("There are more than -2 and less than 12 numbers here");
while (m.find()) {
  System.out.println(m.group());
}

... prints -2 and 12.

-? matches a leading negative sign -- optionally. \d matches a digit, and we need to write \ as \\ in a Java String though. So, \d+ matches 1 or more digits.

Use this regex to select only numbers that aren't connected to any text

\b\d+\b

• \d+ allows any number of digits
• \b at the start and the end defines a word boundary so that it doesn't match words like text12, 9gag, 4chan etc

Demo: https://regex101.com/r/Fzm2PS/2

// Will match 12, 34, 
// Will not match text12, string, 9gag

Pattern.compile("-?[0-9]+(?:,[0-9]+)?")

Explanation

-?        # an optional minus sign
[0-9]+    # decimal digits, at least one
(?:       # begin non-capturing group
  ,       #   the decimal point (German format)
  [0-9]+  #   decimal digits, at least one
)         # end non-capturing group, make optional

Note that this expression makes the decimal part (after the comma) optional, but does not match inputs like -,01.

If your expected input always has both parts (before and after the comma) you can use a simpler expression.

Pattern.compile("-?[0-9]+,[0-9]+")

You need to call matcher.find() recursively until it returns false. Use a do/while block.

String str = '123-456/7890';
Pattern p = Pattern.compile('(\\d+)');
Matcher m = p.matcher( str );

if(m.find()) {
  do {
    system.debug( '-->>' + m.group() );
  } while(m.find());
}

p = Pattern.compile("\\d{10}"); this matches 10 digits but your text "1234568asdjhgsd" only has 7 digits. You can use Pattern.compile("\\d{7}"); and it'll work. But number of digits always has to be <= 7.

Try

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

or

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

References:

• 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"
System.out.println("1".matches(regex));
System.out.println("12345".matches(regex));
System.out.println("123456789".matches(regex));

// negative test cases, should all be "false"
System.out.println("".matches(regex));
System.out.println("foo".matches(regex));
System.out.println("aa123bb".matches(regex));

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);
System.out.println(pattern.matcher("1").matches());
System.out.println(pattern.matcher("12345").matches());
System.out.println(pattern.matcher("123456789").matches());

You can use regex and delete non-digits.

str = str.replaceAll("\\D+","");