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.

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));
}

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).

Java's String.matches function matches the entire string, instead of just one part. That means, it is roughly equivalent to the regex ^[^=]=[^=]$, so both returns false. To build a regex working equivalent to yours, you should use:

str.matches("(?s).*[^=]=[^=].*")

(The (?s) ensures the . matches everything.)

Alternatively, you could build a Pattern and use Matcher for greater flexibility. This is what String.matches uses.

final Pattern p = Pattern.compile("[^=]=[^=]");
final Matcher m = p.matcher(str);
return m.find();

There are two issues with your code

1. \b should be \\b

2. You should be using find() rather than matches(). The first will do a search on a given string and stops when it finds substring that matches the regex. Second will do a search on entire string. Because the provided regex doesn't match with the full string, the matches() does not work.

Simply fix your code on these two points, then it'll work. Tested myself.

As I remember, method matches() searches for exact match only.

matches() means it should match completely, i.e. the whole string fits the RE. Your RE does not allow anything after the ')'. Try using find() instead matches().

Here is the update you need to make to your code - the 2 regexes in the extractor method should be changed to

private static final Pattern THEOREM_REGEX = Pattern.compile(Pattern.quote("\\begin\\{theorem\\}") + "(.+?)" + Pattern.quote("\\end\\{theorem\\}"));
private static final Pattern PROOF_REGEX = Pattern.compile(Pattern.quote("\\begin\\{proof\\}") + "(.+?)" + Pattern.quote("\\end\\{proof\\}"));

The result will be "Hello, World!". See IDEONE demo.

The string you have is actually \begin\{theorem\} Hello, World! \end\{theorem\}. The literal backslashes in Java strings are doubled and when you need to match a literal backslash in Java with a regex, you need to use \\\\. To avoid the backslash hell, Pattern.quote can be of help that will tell the regex to treat all the subpattern inside it as a literal.

More details about Pattern.quote can be found in the documentation:

Returns a literal pattern String for the specified String.
This method produces a String that can be used to create a Pattern that would match the string s as if it were a literal pattern.

Metacharacters or escape sequences in the input sequence will be given no special meaning.

You can use this regex :

^(http://foo.org/)?(query)?([?])?(id)?([=])?([0-9\\&]*)?(apiKey\\=)?([0-9a-z-A-Z]+)$
---------------------------------------------------------------------------------^

You are missing + for that your patter not match because it contain more than one character or number.

ideone demo

I tried this :

String str = "http://foo.org/query?id=234934&apiKey=FNSJDS3442939";
System.out.println(str.matches("^(http://foo.org/)?(query)?([?])?(id)?([=])?([0-9\\&]*)?(apiKey\\=)?([0-9a-z-A-Z]+)$"));

and the output is :

true

Welcome to Java's misnamed .matches() method... It tries and matches ALL the input. Unfortunately, other languages have followed suit :(

If you want to see if the regex matches an input text, use a Pattern, a Matcher and the .find() method of the matcher:

Pattern p = Pattern.compile("[a-z]");
Matcher m = p.matcher(inputstring);
if (m.find())
    // match

If what you want is indeed to see if an input only has lowercase letters, you can use .matches(), but you need to match one or more characters: append a + to your character class, as in [a-z]+. Or use ^[a-z]+$ and .find().

by default Java sticks in the ^ and $ operators, so something like this should work:

public class PatternTest {
  public static void main(String[] args) {
    System.out.println("117_117_0009v0_172_5738_5740".matches("^([0-9_]+v._.).*$"));
  }
}

returns:

true

Match content:

117_117_0009v0_1

This is the code I used to extract the match:

       Pattern p = Pattern.compile("^([0-9_]+v._.).*$");
       String str = "117_117_0009v0_172_5738_5740";

        Matcher m = p.matcher(str);
        if (m.matches())
        {
            System.out.println(m.group(1));
        }

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.