ReplaceAll interesting behavior

Question

The following code seems to loop indefintely:
public class REGEX {
     public static void main(String args[]){
          String string = "https://www.google.com/accounts/ServiceLogin?service=mail&passive=true&rm=false&continue=http%3 - Microsoft Internet Explorer";
          String regex = "&(\\w*\\p{Punct}*)*;";//html encoded stuff
          string = string.replaceAll(regex,"�");
          System.out.println(string);
}What is happening?

Answer 1

Normally, regex quantifiers like * and + are greedy but accomodating: they initially match as many characters as they can, then hand control over to the next part of the regex. If the next part can't match, the quantifier gives up one of whatever it matched and hands off to the next part again. As long as the next part fails to match, the process is repeated until the quantifier has given up everything that it originally matched, whereupon the overall match is deemed a failure.
When you have quantified subexpressions within quantified groups, as in &(\w*\p{Punct}*)*;, the process has to be repeated for each quantifier given every state of every other quantifier, and the number of possible combinations quickly becomes astronomical. If a match is possible, it will usually be found pretty quickly, but if the regex can't match, it will keep trying until the stars burn out before giving up. (That's one reason why you should always test your regexes against invalid data as well as valid data.)
In this case, the regex is much more complicated than it needs to be. When a match is possible, it will match every word character or punctuation character from the first ampersand to the last semicolon. Assuming you can safely ignore control characters, that can be written much more succinctly as &\S*; This still relies on backtracking, but with only the one "path" to follow, it will fail very quickly when it fails. However, if you only want to match up to the first semicolon (or you know there will never be more than one), you can eliminate backtracking entirely by using either a reluctant quantifier: &\S*?; or a possessive quantifer:   &[^\s;]*+; The latter is especially efficient, but you have to be absolutely sure that the quantified part ([^\s;]) can never match in the same place as the sentinel part (;).
Remember, backtracking is your friend, but it's a friend with very poor hygiene and social skills, and it's best to keep it shut away most of the time; think Ed from Shaun of the Dead.