Java regular expression to validate and extract some values

Question

I want to extract all three parts of the following string in Java

MS-1990-10

1. The first part should always be 2 letters ( AZ )
2. The second part should always be a year
3. The third part should always be a number

Does anyone know how can I do that using Java's regular expressions?

Answer 1

You can do this using java's pattern matcher and group syntax:

    Pattern datePatt = Pattern.compile("([A-Z]{2})-(\\d{4})-(\\d{2})");
    Matcher m = datePatt.matcher("MS-1990-10");
    if (m.matches()) {
        String g1 = m.group(1);
        String g2 = m.group(2);
        String g3 = m.group(3);
    }

Answer 2

This is a way to get all 3 parts with a regex:

public class Test {

    public static void main(String... args) {

        Pattern p = Pattern.compile("([A-Z]{2})-(\\d{4})-(\\d{2})");
        Matcher m = p.matcher("MS-1990-10");
        m.matches();
        for (int i = 1; i <= m.groupCount(); i++)
            System.out.println(m.group(i));
    }
}

Answer 3

Use Matcher 's group so you can get the patterns that actually matched. In Matcher , the matches inside parenthesis will be captured and can be retrieved via the group() method. To use parenthesis without capturing the matches, use the non-capturing parenthesis (?:xxx) .

See also Pattern .

public static void main(String[] args) throws Exception {
    String[] lines = { "MS-1990-10", "AA-999-12332", "ZZ-001-000" };

    for (String str : lines) {
        System.out.println(Arrays.toString(parse(str)));
    }
}

private static String[] parse(String str) {
    String regex = "";
    regex = regex + "([A-Z]{2})";
    regex = regex + "[-]";
    // regex = regex + "([^0][0-9]+)"; // any year, no leading zero
    regex = regex + "([12]{1}[0-9]{3})"; // 1000 - 2999
    regex = regex + "[-]";
    regex = regex + "([0-9]+)";

    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(str);
    if (!matcher.matches()) {
        return null;
    }

    String[] tokens = new String[3];
    tokens[0] = matcher.group(1);
    tokens[1] = matcher.group(2);
    tokens[2] = matcher.group(3);
    return tokens;
}

Answer 4

    String rule = "^[A-Z]{2}-[1-9][0-9]{3}-[0-9]{2}";
    Pattern pattern = Pattern.compile(rule);
    Matcher matcher = pattern.matcher(s);

regular matches year between 1000 ~ 9999, u can update as u really need.