Java正则表达式中的所有格限定词有什么用？

Question

I'm reading about regular expression in Java. And I understand that possessive quantifiers do not backtrack and release characters to give a chance for other group to achieve a match. But I couldn't figure any situations where possessive quantifiers are used in reality. I have read some resources saying that since possessive quantifiers don't backtrack, they don't need to remember the position of each character in the input string, which helps to significantly improve performance of the regular expression engine. I have tested this by writing an example:

I have a string containing about thousands of digits.

First I defined a greedy: String regex = "(\\d+)";

Then I counted the time it took.

Second: I change to possessive: String regex = "(\\d++)";

Also I counted the time it took but I don't see any difference in time

Am I misunderstanding something?

And besides, can anyone give me some specific cases where possessive quantifiers are in use?

And about the term: In the book " Java Regular Expressions Taming the Java.Util.Regex Engine by Mehran Habibi " he used the term " possessive qualifiers ", while I read in the Internet, people used " Possessive quantifier ". Which one is correct or both?

Answer 1

Possessive quantifiers are quantifiers that are greedy (they try to match as many characters as possible) and don't backtrack (it is possible matching fails if the possessive quantifiers go to far).

Example

Normal (greedy) quantifiers

Say you have the following regex:

^([A-Za-z0-9]+)([A-Z0-9][A-Z0-9])(.*)

The regex aims to match "one or more alphanumerical-characters (case independent) [A-Za-z0-9] and should end with two alphanumerical characters and then any character can occur.

Any string that obeys this constraint will match. AAA as well. One can claim that the second and the third A should belong to the second group, but that would result in the fact that the string will not match. The regex has thus the intelligence (using dynamic programming), to know when to leave the (first) ship.

Non-greedy quantifiers

Now a problem that can occur is that the first group is "too greedy" for data extraction purposes. Say you have the following string AAAAAAA . Several subdivisions are possible: (A)(AA)(AAAA) , (AA)(AA)(AAA) , etc. By default, each group in a regex is as greedy as possible (as long as this has no effect on the fact whether the string will still be matched). The regex will thus subdivide the string in (AAAAA)(AA)() . If you want to extract data in such a way, that from the moment one character has been passed, from the moment two characters in the [A-Z0-9] range occur, the regex should move to the next group.

In order to achieve this, you can write:

^([A-Za-z0-9]+?)([A-Z0-9][A-Z0-9])(.*)

The string AAAAAAA will match with (A)(AA)(AAAA) .

Possessive quantifiers

Possessive quantifiers are greedy quantifiers, but once it is possible, they will never give a character back to another group. For instance:

^([A-Z]++)([H-Zw])(.*)

If you would write ^([AZ]+)([HZ])(.*) a string AH0 would be matched. The first group is greedy (taking A ), but since eating (that's the word sometimes used) H would result in the string not being matched, it is willingly to give up H . Using the possessive quantifiers. The group is not willing to give up H as well. As a result it eats both A and H . Only 0 is left for the second group, but the second group cannot eat that character. As a result the regex fails where using the non possessive quantifiers would result in a successful match. The string Aw will however successfully match, since the first group is not interested in w ...

Answer 2

By default, quantifers are greedy. They will try to match as much as possible. The possessive quantifier prevents backtracking, meaning what gets matched by the regular expression will not be backtracked into, even if that causes the whole match to fail. As stated in Regex Tutorial ( Possessive Quantifiers ) ...

Possessive quantifiers are a way to prevent the regex engine from trying all permutations. This is primarily useful for performance reasons. You can also use possessive quantifiers to eliminate certain matches.