I am trying to apply the below pattern:
Pattern p = Pattern.compile(".*?");
Matcher m = p.matcher("RAJ");
StringBuffer sb = new StringBufffer();
while(m.find()) {
m.appendReplacement(sb, "L");
}
m.appendTail(sb);
Expected Output : LLL Actual output : LRLALJL
Does the Dot(.) in the above regex match the position between the characters? If not why is the above output received
The .*? matches any number of characters, but as few as necessary to match the whole regex (the ? makes the * reluctant (also known as lazy)). Since there's nothing after that in the regex, this will always match the empty string (a.k.a the place between characters).
If you want at least a single character to be matched try .+?. Note that this is the same as just . if there's nothing else after it in the regex.
.*? to a greedy .* you'd get LL as a result, and a greedy .+ would give you simply L. As you pointed out, .+? yields the correct output, but only because it acts like .. The real solution is to get rid of the quantifier, as @rmunoz demonstrated.You can get it doing this:
String s = "RAJ";
s = s.replaceAll(".","L");
System.out.println(s);
You can do it using a Matcher and find method, but replaceAll accepts a regex.
.+? is effectively the same as .) and yes, replaceAll() (found in the String class as well as well as in Matcher) does the same thing as the code in the question.
It is not that . matches between the characters, but that * means 0 or more and the ? means as few as possible.
So "Zero or more things, and as few of them as possible" will always match Zero things, as that is the fewest possible, if it's not followed by something else the expression is looking for.
.{1} would result in an output of LLL as it matches anything once.
. alone will match once--or more precisely, it will consume exactly one character. The {1} pseudo-quantifier has no effect.The * in your regex .*? means none or more repetitions. If you want to match at least a single character use the regex .+?.
