java regex help

[Rick Venter]

I am trying to create a regular expression for matching a pattern with
a string enclosed in curly braces { } and not able to do that using
java.

For ex: if the String is
foo {bar} alpha {baz}:{bat} gamma

I need the strings:
{bar}
{baz}
{bat}

after the pattern matching

How do I do that ? Following is the code snippet and it is not
printing out anything. I think my regular expression pattern might be
wrong.

Can anyone help ?

protected static final String PARAMETER_REGEX =
"\\{\\[\\^\\{\\}\\]+\\}";

String originalString = "foo {bar} alpha {baz}:{bat} gamma";

Pattern p = Pattern.compile(PARAMETER_REGEX);
Matcher m = p.matcher(originalString);

while(m.find()) {
System.out.println(matcher.group());
}

 

[VisionSet]

I am trying to create a regular expression for matching a pattern with
a string enclosed in curly braces { } and not able to do that using
java.

Braces have special meaning ie quantity of previous character/group.
Therefore to match as regular characters they need escaping with /
So try:

\\{[^\\{\\}]+\\}

Oh now I see the rest of your explanation.

Just don't escape the [ or ] you need them with their special meaning ie
character class.

 

[Roedy Green]

Braces have special meaning ie quantity of previous character/group.
Therefore to match as regular characters they need escaping with /

If you get discombobulated with regex quoting, there is help. See
http://mindprod.com/quoter.html it will apply the quoting for you as
if you meant everything literally.

What we really need is http://mindprod.com/projregexproofreader.html

 

[Alan Moore]

protected static final String PARAMETER_REGEX =
"\\{\\[\\^\\{\\}\\]+\\}";

String originalString = "foo {bar} alpha {baz}:{bat} gamma";

Pattern p = Pattern.compile(PARAMETER_REGEX);
Matcher m = p.matcher(originalString);

while(m.find()) {
System.out.println(matcher.group());
}

"\\{[^{}]+\\}"

You don't escape the '[', '^', or ']' because you *want* them to be
treated as metacharacters. And you don't need to escape the inner '{'
and '}' (though it doesn't hurt) because they're in a character class,
where they aren't treated as metacharacters anyway.

Also, if you're going to the trouble of creating a constant for the
regex, why not make it the compiled Pattern instead? That way, you'll
only have to compile it once, no matter how many times you use it.

protected static final Pattern PARAMETER_PATTERN =
Pattern.compile("\\{[^{}]+\\}");

 

[John C. Bollinger]

protected static final String PARAMETER_REGEX =
"\\{\\[\\^\\{\\}\\]+\\}";

String originalString = "foo {bar} alpha {baz}:{bat} gamma";

Pattern p = Pattern.compile(PARAMETER_REGEX);
Matcher m = p.matcher(originalString);

while(m.find()) {
System.out.println(matcher.group());
}

"\\{[^{}]+\\}"

You don't escape the '[', '^', or ']' because you *want* them to be
treated as metacharacters. And you don't need to escape the inner '{'
and '}' (though it doesn't hurt) because they're in a character class,
where they aren't treated as metacharacters anyway.

Also, if you're going to the trouble of creating a constant for the
regex, why not make it the compiled Pattern instead? That way, you'll
only have to compile it once, no matter how many times you use it.

protected static final Pattern PARAMETER_PATTERN =
Pattern.compile("\\{[^{}]+\\}");

Even simpler would be to use a ruluctant quantifier instead of a greedy
one, ala "\\{.+?\\}". (Read: opening '{' + one or more characters up to
and including the _first_ '}'.) That does change the semantics
slightly, however, in that it does not reject strings with internal
opening '{' characters. The pattern could be adjusted to account for
that, but then there would be no simplicity advantage to using the
reluctant form of the quantifier.


John Bollinger
(e-mail address removed)

 

[Alan Moore]

protected static final String PARAMETER_REGEX =
"\\{\\[\\^\\{\\}\\]+\\}";

String originalString = "foo {bar} alpha {baz}:{bat} gamma";

Pattern p = Pattern.compile(PARAMETER_REGEX);
Matcher m = p.matcher(originalString);

while(m.find()) {
System.out.println(matcher.group());
}

"\\{[^{}]+\\}"

You don't escape the '[', '^', or ']' because you *want* them to be
treated as metacharacters. And you don't need to escape the inner '{'
and '}' (though it doesn't hurt) because they're in a character class,
where they aren't treated as metacharacters anyway.

Even simpler would be to use a ruluctant quantifier instead of a greedy
one, ala "\\{.+?\\}". (Read: opening '{' + one or more characters up to
and including the _first_ '}'.) That does change the semantics
slightly, however, in that it does not reject strings with internal
opening '{' characters. The pattern could be adjusted to account for
that, but then there would be no simplicity advantage to using the
reluctant form of the quantifier.

Also, since the dot doesn't match line separators (unless you use the
DOTALL flag), the whole sequence would have to be on one line for the
regex to match--which is probably a good thing, come to think of it.