Java Regular expression on subgroup

Question

I have the following question about Java Regular expression.

When I am defining a regular expression using pattern:

String pattern = "(\\d{4})\\d{2}\\d{2}";

and the input string is "20180808", I can get the group(0) - 20180808
but

group(1) - not match
group (2) - 08
group (3) - 08,

I am sure the regular expression can be effective in other languages, like Python, C#.

Can anyone Help? thanks for your expert solution.

@Test
public void testParseDateStringToMinimumOfTheDate() {
    try {
        UtilsFactory utilsFactory = UtilsFactory.getInstance();
        DateUtils dateUtils = utilsFactory.getInstanceOfDateUtils();
        CalendarUtils calendarUtils = utilsFactory.getInstanceOfCalendarUtils();
        calendarUtils.parseDateStringToMinimumOfTheDate("20180808");
    } catch (Exception e) {
        e.printStackTrace();
    }
} 

    public Calendar parseDateStringToMinimumOfTheDate(String dateString_yyyyMMdd) throws Exception {
    Calendar cal = null;
    String pattern = "(\\d{4})\\d{2}\\d{2}";
    try {
        cal = getMaxUtcCalendarToday();
        List<String> matchStringList = regMatch(dateString_yyyyMMdd, pattern);
        for (int i = 0; i < matchStringList.size(); i++) {

        }
    } catch (Exception e) {
        logger.error(getClassName() + ".parseDateStringToBeginningOfTheDate()- dateString_yyyyMMdd="
                + dateString_yyyyMMdd, e);
        throw e;
    }
    return cal;
}

private List<String> regMatch(String sourceString, String patternString) throws Exception {
    List<String> matchStrList = null;
    Pattern pattern = null;
    Matcher matcher = null;
    try {
        matchStrList = new ArrayList<String>();
        pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
        matcher = pattern.matcher(sourceString);
        while (matcher.find()) {
            matchStrList.add(matcher.group());
        }
    } catch (Exception e) {
        logger.error(
                getClassName() + ".regMatch() - sourceString=" + sourceString + ",patternString=" + patternString,
                e);
        throw e;
    }
    return matchStrList;
}

Answer 1

    Pattern pattern = Pattern.compile("\\d{8}");
    String sourceString = "20180808";
    Matcher matcher = pattern.matcher(sourceString);
    while (matcher.find()) {
        LocalDate date = LocalDate.parse(matcher.group(), DateTimeFormatter.BASIC_ISO_DATE);
        System.out.println(date);
    }

The output from this snippet is the expected date:

2018-08-08

If your string may contain more text than just the 8 digit date, it is correct to use a regular expression for taking out those 8 digits. The correct class to use for a date is LocalDate from java.time, the modern Java date and time API. it’s a date in the ISO calendar system without time of day and without time zone. The Calendar, by contrast, represents date and time with time zone in some calendar system. It’s much more than you need. Also the Calendar class is long outdated and was replaced by java.time four and a half years ago because it was poorly designed.

If you do need a Calendar object for some legacy API that you cannot change or don’t want to change just now, convert like this:

        ZoneId zone = ZoneId.of("America/Punta_Arenas");
        ZonedDateTime startOfDay = date.atStartOfDay(zone);
        Calendar cal = GregorianCalendar.from(startOfDay);

Please substitute the correct time zone if it didn’t happen to be America/Punta_Arenas.

What went wrong in your code?

There’s nothing wrong with your code except that it’s overly complicated and uses the outdated date and time classes.

    String patternString = "(\\d{4})(\\d{2})(\\d{2})";
    Pattern pattern = null;
    Matcher matcher = null;
    try {
        pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
        matcher = pattern.matcher(sourceString);
        while (matcher.find()) {
            System.out.println("group(1): " + matcher.group(1));
            System.out.println("group(2): " + matcher.group(2));
            System.out.println("group(3): " + matcher.group(3));
        }
    } catch (Exception e) {
        // TODO handle exception
        throw e;
    }

The output from this snippet was:

group(1): 2018
group(2): 08
group(3): 08

Link

Oracle tutorial: Date Time explaining how to use java.time.

Answer 2

There is nothing wrong with your regex (As you mentioned (\d{4})(\d{2})(\d{2}). What you are doing wrong is, you are not grabbing the captured group properly. Refactor your method to this

private static List<String> regMatch(String sourceString, String patternString) {
      List<String> matchStrList = new ArrayList<>();

      Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
      Matcher matcher = pattern.matcher(sourceString);

      if(matcher.find()) {
          for(int i = 1; i <= matcher.groupCount(); i++) {
            matchStrList.add(matcher.group(i));
          }
      }

   return matchStrList;
}

You might wonder where is the group 0. Patter API captured groups are numbered by counting their opening parentheses from left to right and the first group is always the whole regular expression. So for the String (A)(B(C)) You will get the groups as below

Group 0: (A)(B(C))
Group 1: (A)
Group 2: (B(C))
Group 3: (C)

And the groupCount() method returns the number of capturing groups present in the matcher's pattern.

Side Note

As @haba713 mentioned in the comment, you might don't want to do all these regex hassle just to parse a Date. You can simply use SimpleDateFormat for this.

SimpleDateFormat formater = new SimpleDateFormat("yyyyMMdd");
System.out.println(formater.parse(dateString));