Regular Expression compilation problem

Question

I am trying to use JDK 1.4's regular expression classes to match text that appears with curly braces (e.g. {field1}) using the following regular expression:
[{]([0-9A-Za-z]+)[}]
I use this same pattern with the org.apache.regexp and org.apache.oro packages without any problem, but get the following error when running it using the new java.util.regex package in JDK 1.4:
Exception in thread "main" java.util.regex.PatternSyntaxException: Unexpected character '?' near index 0
[{]([0-9A-Za-z]+)[}]
^
at java.util.regex.Pattern.error(Pattern.java:1472)
at java.util.regex.Pattern.range(Pattern.java:2052)
at java.util.regex.Pattern.clazz(Pattern.java:1991)
at java.util.regex.Pattern.sequence(Pattern.java:1529)
at java.util.regex.Pattern.expr(Pattern.java:1489)
at java.util.regex.Pattern.compile(Pattern.java:1257)
at java.util.regex.Pattern.<init>(Pattern.java:1013)
at java.util.regex.Pattern.compile(Pattern.java:760)
at Test_jdk14.main(Test_jdk14.java:13)
What am I doing wrong?
Thanks, Tony

Answer 1

Hello,
Let's look at what you've done.
[\\{]([0-9A-Za-z]+)[}]Okay, first you escape the opening curly brace, but you did not escape the closing curly brace.
[\\{]([0-9A-Za-z]+)[\\}]Next, you use the square brackets, but you only have one thing in the brackets, so, they are unnecessary:
\\{([0-9A-Za-z]+)\\}Next, I am going to contract all that stuff inside your remaining square brackets to \\w, since that covers 0-9A-Za-z_
\\{(\\w+)\\}Now, are you expecting any sort of spaces within the curly brackets? If so, you didn't specify them. I'll assume you didn't.
Now you did all this, but it still doesn't match what you thought it would match. Did you use Matcher.matches or Matcher.lookingAt?
If you look at the API for these methods, you'll see that
a) Matcher.matches(...) only returns true if the entire input sequence matches the pattern.
b) Matcher.lookingAt(...) only returns true if the start of the input sequence matches the pattern.
In either of these cases, if your string didn't start with the opening bracket, then the Pattern (in its current form) won't match. For example:
"{text1}"                       // matches() == true
                                // lookingAt() == true
"{text2} blah blah"             // matches() == false
                                // lookingAt() == true
"blah blah {text3}"             // matches() == false
                                // lookingAt() == false
"blah blah {text4} blah blah"   // matches() == false
                                // lookingAt() == false
                                //You would want to use Matcher.find() if you want to find all of these matches.
However, there is a way to find those matches using Matcher.matches() and Matcher.lookingAt(). All you have to do is put .* in front and behind the thing you're looking for.
.*\\{([\\w]+)\\}.*This way, any number of characters can come before or after your pattern, and it will still fit the requirements.
Here's an example:
import java.util.*;
import java.util.regex.*;
public class RegExample
   public static void main( String [] args )
      Pattern p = Pattern.compile( ".*\\{(\\w+)\\}.*" );
      Matcher m = p.matcher( "blah blah {field1} blah blah" );
      if ( m.lookingAt() )
         System.out.println( "We're looking at it." );
      if ( m.matches() )
         System.out.println( "It matches." );
      m.reset();
      if ( m.find() )
         System.out.println( "we found the first match" );
         System.out.println( "It was: " + m.group(1) );
}