Matcher.matches() matches the complete string. You can use Matcher.find to match the individual integers:

while (m.find()) {
  System.out.println(m.group(1));
}

Matcher.matches returns true only if the ENTIRE region matches the pattern.

For the output you are looking for, use Matcher.find instead

Explanation of each case:

Pattern p = Pattern.compile("[^A-Z]+");
Matcher matcher = p.matcher("GETs");
  if (matcher.matches()) {

Fails because the ENTIRE region 'GETs' isn't lowercase

Pattern p = Pattern.compile("[A-Z]+");
Matcher matcher = p.matcher("GETs");
  if (matcher.matches()) {

This fails because the ENTIRE region 'GETs' isn't uppercase

Pattern p = Pattern.compile("[A-Z]+");
Matcher matcher = p.matcher("GET");
  if (matcher.matches()) {

The ENTIRE region 'GET' is uppercase, the pattern matches.

You can't ask a Matcher to give a .group() unless you have called a method which asks the Matcher to operate on the input: one of .find() (preferred), .lookingAt() or .matches().

This is why you get an IllegalStateException.

As to the differences between the three, while the javadoc tells it all, just a quick reminder:

• .find() does "real" regex matching: it will try and match the regex anywhere in the input text;
• .lookingAt() adds the constraint that the pattern should match at the beginning of the input text;
• .matches() is a misnomer since in addition to the constraint imposed by .lookingAt(), it also required that the full input text (the "entire region" in the javadoc) is matched.

Please also recall that those three methods return a boolean depending on whether the match was successful; if the result is false, you can't .group().

See comments in the code and explanation below:

String cstring = "public class hello extends jframe ";
Pattern classPattern = Pattern.compile(".*?class\\s+(\\S+)\\s*"); // regex was changed a bit
Matcher m = classPattern.matcher(cstring);
//m.matches();  // <-- no need for that 
if (m.find()) { // use find() instead of m.hitEnd()
    System.out.println("found");
    String className = m.group(1);
    System.out.println(className);
}

OUTPUT

found
hello

Basically I removed the (public) from the regex and used the "1" matched group (zero is the whole expression in case there is a match). Your regex could be used as well, but then you'll have to use the seconded matched group as (public) will be come the first.

In addition to that I removed m.matches() which is not needed and replaced the m.hitEnd() with m.find() which should be used to iterate the matched results.

You may add a |(.) alternative to your pattern (to match any char but a line break char) and check if Group 1 matched upon each match. If yes, output false, else, output true:

String argument = "#a1^b2";
Pattern pattern = Pattern.compile("[a-zA-Z]|[0-9]|\\s|(.)"); // or "[a-zA-Z0-9\\s]|(.)"
Matcher matcher = pattern.matcher(argument);

while(matcher.find()) {                           // find all matching characters
    System.out.println(matcher.group(1) == null);

See the Java demo, output:

false
true
true
false
true
true

Note you do not need to use a Pattern.DOTALL here, because \s in your "whitelist" part of the pattern matches line breaks.

Try calling

m.find();

after the .matcher statement.

This will find all occurrences from your string.

   final Pattern pattern = Pattern.compile(regex);
   final Matcher matcher = pattern.matcher(string);
   
   while (matcher.find()) {
       
       System.out.println("Full match: " + matcher.group());
   }

You have to call myMatcher.find(). Calling matches just tells you if the expression matches the whole input. Also note that you need to escape your special characters (\\b) and you probably want to search only up to the end of the line ($). That will only work if you set the multi-line flag, otherwise $ means end of string.

Matcher m = Pattern.compile('(?m)^aaaa\\b.*$')
    .matcher('aaaa,bbbb\ncccc,dddd');
if (m.find())
{
    system.debug(m.groupCount());
    system.debug(m.group());
}

The pattern "(FFF1|FFF3){4,}" will match FFF1 or FFF3 placed adjacent, with a repetition of 4 or more. I guess there can be any characters between multiple occurrences. In that case, use the following regex:

"^(?:.*?(FFF1|FFF3)){4,}.*$"

.*? match any character till the next FFF1 or FFF3, then match FFF1|FFF3. Repeat this sequence 4 or more times (applied on entire non-capturing group).

You can use the above pattern directly with String#matches(String) method. Or, if you are building Pattern and Matcher objects, then just use the following pattern with Matcher#find() method:

"(?:.*?(FFF1|FFF3)){4,}"

Working code:

String str = "...";  // initialize

Pattern mPattern = Pattern.compile("(?x)" +  // Ignore whitespace
                        "(?:            " +  // Non-capturing group
                        "   .*?         " +    // 0 or more repetition of any character
                        "   (FFF1|FFF3) " +    // FFF1 or FFF3
                        "){4,}          "    // Group close. Match group 4 or more times
                                  );  

Matcher matcher = mPattern.matcher(str);        
System.out.println(matcher.find()); 

You need to call Matcher#find() to actually get a match:

Pattern p = Pattern.compile("([0-9]+)-([0-9]+)-([0-9]+)-([0-9]+)-([0-9]+)");
Matcher matcher = p.matcher("1-1-3-1-4");
if (matcher.find()) {
    System.out.println(matcher.group(0))
}

If you were expecting multiple matches, you could use a while loop instead of an if statement.

Also note that you actually have five capture groups in your patterns. Capture groups are denoted by placing a portion of the pattern in parentheses. If you don't intend/need to capture the five separated numbers in your pattern individually, then you can consider telling the regex engine not to capture them, e.g. use this:

Pattern p = Pattern.compile("(?:[0-9]+)-(?:[0-9]+)-(?:[0-9]+)-(?:[0-9]+)-(?:[0-9]+)");

Demo

You first need to do

matcher.find()

to trigger the actual search. Usually like this:

Pattern pattern = Pattern.compile("(browse/)(.*)(\">)");
Matcher matcher = pattern.matcher(match);
if (matcher.find()) 
    return matcher.group(1);

You should probably be using a different regex, though:

Pattern pattern = Pattern.compile("browse/([^<>\"]*)\">");

will be safer and more efficient (and provide the correct value in group number 1).