What's up with this regular expression not matching?

public class PatternTest {
  public static void main(String[] args) {
    System.out.println("117_117_0009v0_172_5738_5740".matches("^([0-9_]+v._.)"));
  }
}

This program prints "false". What?!

I am expecting to match the prefix of the string: "117_117_0009v0_1"

I know this stuff, really I do... but for the life of me, I've been staring at this for 20 minutes and have tried every variation I can think of and I'm obviously missi开发者_JAVA百科ng something simple and obvious here.

Hoping the many eyes of SO can pick it out for me before I lose my mind over this.

Thanks!

The final working version ended up as:

String text = "117_117_0009v0_172_5738_5740";
String regex = "[0-9_]+v._.";

Pattern p = Pattern.compile(regex);

Mather m = p.matcher(text);
if (m.lookingAt()) {
  System.out.println(m.group());
}

One non-obvious discovery/reminder for me was that before accessing matcher groups, one of matches() lookingAt() or find() must be called. If not an IllegalStateException is thrown with the unhelpful message "Match not found". Despite this, groupCount() will still return non-zero, but it lies. Do not beleive it.

I forgot how ugly this API is. Argh...

by default Java sticks in the ^ and $ operators, so something like this should work:

public class PatternTest {
  public static void main(String[] args) {
    System.out.println("117_117_0009v0_172_5738_5740".matches("^([0-9_]+v._.).*$"));
  }
}

returns:

true

Match content:

117_117_0009v0_1

This is the code I used to extract the match:

       Pattern p = Pattern.compile("^([0-9_]+v._.).*$");
       String str = "117_117_0009v0_172_5738_5740";

        Matcher m = p.matcher(str);
        if (m.matches())
        {
            System.out.println(m.group(1));
        }

If you want to check if a string starts with the certain pattern you should use Matcher.lookingAt() method:

Pattern pattern = Pattern.compile("([0-9_]+v._.)");
Matcher matcher = pattern.matcher("117_117_0009v0_172_5738_5740");
if (matcher.lookingAt()) {
  int groupCount = matcher.groupCount();
  for (int i = 0; i <= groupCount; i++) {
     System.out.println(i + " : " + matcher.group(i));
  }
}

Javadoc:

boolean java.util.regex.Matcher.lookingAt()

Attempts to match the input sequence, starting at the beginning of the region, against the pattern. Like the matches method, this method always starts at the beginning of the region; unlike that method, it does not require that the entire region be matched. If the match succeeds then more information can be obtained via the start, end, and group methods.

I donno Java Flavor of Regular Expression However This PCRE Regular Expression Should work ^([\d_]+v\d_\d).+ Dont know why you are using ._. instead of \d_\d