Util.regex.Pattern documentation

Question

The 1.5 documentation for util.regex.Pattern defines quantifiers that are greedy, reluctant, or possessive. The definitions of these quantifiers seem to be the same. For example, X?, X??, and X?+ are each defined as "X, once or not at all." Is this a mistake? If not, what's that difference among greedy, reluctant, and possessive?

Answer 1

It's not a mistake, it's just incomplete. A normal (greedy) quantifier matches as many times as it can, but will back off if necessary to achieve an overall match. A reluctant quantifier matches the minimum number of times that it has to, and only tries to match more if that's the only way to achieve an overall match. A greedy quantifier matches as many times as it can and never backs off, even if that makes an overall match impossible. Here's a demonstration:import java.util.regex.*;
public class Test
  public static void main(String[] args)
    String input = "XXXXX";
    Pattern p1 = Pattern.compile("(X+)(X+)");
    Pattern p2 = Pattern.compile("(X+?)(X+)");
    Pattern p3 = Pattern.compile("(X++)(X+)");
    Matcher m = p1.matcher(input);
    if (m.matches())
       System.out.println("p1:\t" + m.group(1) + "\t" + m.group(2));
    m = p2.matcher(input);
    if (m.matches())
       System.out.println("p2:\t" + m.group(1) + "\t" + m.group(2));
    m = p3.matcher(input);
    if (m.matches())
       System.out.println("p3:\t" + m.group(1) + "\t" + m.group(2));
p1:     XXXX    X
p2:     X       XXXXIn p1, the X+ in the first group initially matches all five X's, then hands off to the second group. The X+ there has to match at least one X, but there are none left. So the first group gives up one of its X's, the second group matches it, and Bob's your uncle.
In p2, the X+? has to match at least one X, so it does, then hands off to the second group, which happily gobbles up the rest of the input.
In p3, the X++ matches all the X's, but refuses to back off and give the X+ in the second group the one X it needs, so the match fails.