将字符串与多个正则表达式模式匹配，然后返回组号

Question

I'm working with regular expressions in Java using Matcher class

Here is a description of what I have:

I have a multiple regex separated by pipes. I have to get the group of the words that matches one of the regular expressions.

this is the pattern variable :

private static Pattern pattern = Pattern.compile(
        "^TDXF.*\\w+-(\\d+)(\\.\\d+)+_(\\d+\\.)+\\d+|^TD.{3}([0-9]).{4}$|^.*_.*-.*-([0-9]*)\\..*\\..*\\..*$");

and this method is used to return the group number associated to the word.

private static String getGroup(String gp) {
    String g= "";
    if (gp== null) {
        return g;
    }

    final Matcher matcher = pattern.matcher(gp);
    if (matcher.matches()) {
 g= matcher.group(1) != null ? matcher.group(1) : matcher.group(2);
    }
    return g;
}

I wrote a unit test to test if it works for this string for example : TD91160152 but it failed.

 @Test
public void testGroup() {
    Assert.assertEquals("6", this.getStep("TD91160152"));
    Assert.assertEquals("2", this.getStep("TDXF-tv-2.5.10.1_0.0.0.0"));
    Assert.assertEquals("6", this.getStep("TD91160118_SF11043004"));

    Assert.assertEquals("3", this.getStep("TDXF_sih-tv-3.4.12.1_7.21.3.1"));
    Assert.assertEquals("5", this.getStep("TD20_sih-tv-5.2.20.1"));
    Assert.assertEquals("5", this.getStep("TD30_sih-tv-5.15.8.1"));
}

TD91160152 matches this pattern ^TD.{3}([0-9]).{4}$ and it should return 6 as a matcher.group(1) number : see this demo

I don't know why it fails and return null as a group number. I don't think that it's related to overlaps between the regex.

I tried to remove the other patterns and only put

private static Pattern pattern = Pattern.compile(
        "^TD.{3}([0-9]).{4}$");

and it worked.. I don't know why when I add the other regex it returns null.

can anyone help me on this? Thanks a lot.

Answer 1

I tested your regex, looks like its fine. Maybe you need other function or flags in your regex expression? Screenshots i made here

Regex

Matches

Groups

Answer 2

Thanks to every one who toke time to read and think with me for a solution. Hopefully I found a solution. I ended up by separating the patterns and the test if the word matches the pattern. (maybe ther's a confusion somewhere when using the iterator | )

private static Pattern p1 = Pattern.compile("^TDXF.*\\w+-(\\d+)(\\.\\d+)+_(\\d+\\.)+\\d+");

private static Pattern p2 = Pattern.compile("^TD.{3}([0-9]).{4}$");

private static Pattern p3 = Pattern.compile("^.*_.*-.*-([0-9]*)\\..*\\..*\\..*$");

private static String getGroup(String gp) {
    String g = "";
    if (gp== null) {
        return g;
    }

    final Matcher matcher1 = p1.matcher(gp);
    final Matcher matcher2 = p2.matcher(gp);
    final Matcher matcher3 = p3.matcher(gp);

    if (matcher1.matches()) {
        g= matcher1.group(1) != null ? matcher1.group(1) : matcher1.group(2);
    }
    if (matcher2.matches()) {
        g= matcher2.group(1) != null ? matcher2.group(1) : matcher2.group(2);
    }
    if (matcher3.matches()) {
        g= matcher3.group(1) != null ? matcher3.group(1) : matcher3.group(2);
    }
    return g;
}

Answer 3

The value TD91160152 matches the second part of your regex but the group is the 4th group in your total regex. So you need to use getGroup(4) to get 6

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Ff {
    static String part1="^TDXF.*\\w+-(\\d+)(\\.\\d+)+_(\\d+\\.)+\\d+$";
    static String part2 = "^TD.{3}([0-9]).{4}$";
    static String part3 = "^.*_.*-.*-([0-9]*)\\..*\\..*\\..*$";
    private static Pattern pattern = Pattern.compile(part1+"|"+part2+"|"+part3);


    public static void main(String args[]) {
        Matcher m=pattern.matcher("TD98760452");
        if(m.matches())
        {
            for (int i=1;i<=m.groupCount();i++)
                System.out.println(m.group(i));
        }
    }
}

The output is

null
null
null
6
null