> Hello,
> I have learned Java Regular expression for a long time, but still
[quoted text clipped - 19 lines]
> here "a??" is Reluctant quantifiers but why all char 'a' not match
> successful?
The definition of "a?" means that either a is matched or it isn't.
Without a quantifier, it attempts to match a first and only omit the a
when it can't match. However, you specified the reluctant quantifier,
which makes the `?' operator attempt to not match first.
Psuedocode for "a?":
try to match `a' and then the rest of the regex
if match fails:
try to match nothing and rest of regex
return result of match
else:
return true
For "a??":
try to match nothing and then the rest of the regex
if match fails:
try to match `a' and rest of regex
return result of match
else:
return true
Since "a??" is the full regex, the first attempt (to match nothing) will
succeed at every point, and the fall back of matching `a' will never occur.
> when I use greedy quantifiers Pattern p = Pattern.compile("a?");
> the output result is:
[quoted text clipped - 6 lines]
> but why the emtry char at (0,0) (1,1) (2,2) can't match successful
> compare with Reluctant quantifiers ?
Greedy means, essentially, to assume that a match will work and only
unmatch a character if it doesn't work. Reluctant quantifiers will
attempt to match the rest of the regex and only match more if it has to.
A typical example is this:
Finding a closing parenthesis in an arithmetic expression (can't handle
nested):
"(1+4)*5-6/(1+9)": the obvious regex "\\(.*\\)" will match the entire
string, whereas "\\(.*?\\)" will match only "(1+4)".
If you want to match "aaa", the regex "a*" or "a+" will do so.
Finally, there is the possessive quantifier, which refuses to backtrack
on failed matches. I can imagine that there are times when this would be
helpful, but none that I can think of off the top of my head...

Signature
Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth
NeoGeoSNK - 03 Mar 2008 08:45 GMT
> > Hello,
> > I have learned Java Regular expression for a long time, but still
[quoted text clipped - 74 lines]
> Beware of bugs in the above code; I have only proved it correct, not
> tried it. -- Donald E. Knuth
Thanks, It's very clear,
> The definition of "a?" means that either a is matched or it isn't.
> Without a quantifier, it attempts to match a first and only omit the a
> when it can't match. However, you specified the reluctant quantifier,
> which makes the `?' operator attempt to not match first.
so do you mean:
X? meaning X,once or not at all
but
X?? meaning not at all or X,once
one question is:
> "(1+4)*5-6/(1+9)": the obvious regex "\\(.*\\)" will match the entire
> string, whereas "\\(.*?\\)" will match only "(1+4)".
I have test it, and "\\(.*?\\)" match both (1+4) and (1+9), why do you
think it only match (1+4) ?
Thanks for your repay again.
Lars Enderin - 03 Mar 2008 12:25 GMT
NeoGeoSNK skrev:
>>> Hello,
>>> I have learned Java Regular expression for a long time, but still
[quoted text clipped - 17 lines]
> I have test it, and "\\(.*?\\)" match both (1+4) and (1+9), why do you
> think it only match (1+4) ?
That regexp matches first (1+4), then (1+9). The other regexp matches
from the first ( up to and including the last ), once.
Joshua Cranmer - 03 Mar 2008 21:49 GMT
>> The definition of "a?" means that either a is matched or it isn't.
>> Without a quantifier, it attempts to match a first and only omit the a
[quoted text clipped - 4 lines]
> but
> X?? meaning not at all or X,once
Right.
>> "(1+4)*5-6/(1+9)": the obvious regex "\\(.*\\)" will match the entire
>> string, whereas "\\(.*?\\)" will match only "(1+4)".
>>
> I have test it, and "\\(.*?\\)" match both (1+4) and (1+9), why do you
> think it only match (1+4) ?
Oops, I should have been clearer. "(1+9)" will be matched as well. What
I had intended to say was that the first match would not match the whole
string but merely the indicated substring.

Signature
Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth