Simplifying Regex Expression: calendar

Question

I want to parse a date string with the following general format: Weekday, DD-Mon-YYYY HH:MM:SS. The calendar should also accept:

1. a date without the weekday
2. spaces instead of dashes
3. case-insensitive month (e.g., allow "Jan", "JAN" and "jAn")
4. two-digit year
5. a missing timezone
6. allow multiple spaces wherever a single space is allowed.

Return null when:

Input isn't a valid date string, meaning only checks that don't require connecting different. Example: the weekday string "XXX" is invalid but "Fri, 09-Jun-2015" is considered valid even though it was a Tuesday

My code:

public static Calendar parseDate(String input) {
 List<String> months = Arrays.asList("jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec");
 Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
 Pattern pattern = Pattern.compile ("(?:[A-Z][a-z][a-z],\\s+)?([0-2][0-9]|[3][0-1])(?:\\s+|-)([a-zA-z]{3})(?:\\s+|-)([0-9]{2,4})(?:\\s+)([0-1][0-9]|[2][0-3]):([0-5][0-9]):([0-9]{2})(?:\\s+GMT|$)");
 Matcher matcher = pattern.matcher (input);
 Calendar calendar = Calendar.getInstance (TimeZone.getTimeZone ("GTM"));
 if ( !matcher.find () ){
 return null;
 }
 int dayOfMonth = Integer.parseInt (matcher.group (1)); //since the first group is the time zone
 int month = months.indexOf (months.indexOf(matcher.group(2).toLowerCase()));
 int year = Integer.parseInt (matcher.group (3));
 if (year >= 0 && year <= 69){
 year += 2000;
 }
 if ( year >= 70 && year <= 99 ) {
 year += 1900;
 }
 int hours = Integer.parseInt(matcher.group(4));
 int minutes = Integer.parseInt(matcher.group(5));
 int seconds = Integer.parseInt(matcher.group(6));
 cal.set(year, month, dayOfMonth, hours, minutes, seconds);
 return calendar;
}

My question is how to improve "(?:[A-Z][a-z][a-z],\\s+)?([0-2][0-9]|[3][0-1])(?:\\s+|-)([a-zA-z]{3})(?:\\s+|-)([0-9]{2,4})(?:\\s+)([0-1][0-9]|[2][0-3]):([0-5][0-9]):([0-9]{2})(?:\\s+GMT|$)"?
EDIT: I can only import regex matcher and pattern and ArrayList, and the only additional methods allowed are: months.indexOf, Calendar.set, Integer.parseInt and String.toLowerCase
Tester:

public void testParseDate() {
 DateFormat df = DateFormat.getDateTimeInstance();
 df.setTimeZone(TimeZone.getTimeZone("GMT"));
 ArrayList<String> inputs = new ArrayList<String>();
 ArrayList<Long> expect = new ArrayList<Long>();
 Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
 cal.set(Calendar.MILLISECOND, 0);
 cal.set(2012,4,23,1,23,31);
 long time1 = cal.getTimeInMillis();
 inputs.add("Wed, 23-May-12 01:23:31 GMT"); expect.add(time1); 
 inputs.add("23-May-12 01:23:31 GMT"); expect.add(time1); 
 inputs.add("23-May-12 01:23:31"); expect.add(time1); 
 inputs.add("23 May 2012 01:23:31 GMT"); expect.add(time1); 
 inputs.add("23 May 2012 01:23:31 GMT"); expect.add(time1);
 inputs.add("Wed, 23 May 2012 01:23:31 GMT"); expect.add(time1);
 inputs.add("23 mAy 2012 01:23:31 GMT"); expect.add(time1);
 inputs.add("23 maY 12 01:23:31"); expect.add(time1);
 inputs.add("23 jan 12 01:23:31"); cal.set(2012,0,23,1,23,31); expect.add(cal.getTimeInMillis());
 inputs.add("01 AUG 12 15:23:31 GMT"); cal.set(2012,7,1,15,23,31); expect.add(cal.getTimeInMillis());
 inputs.add("01 bla 12 15:23:31 GMT"); expect.add(null);
 inputs.add("1 May 2012 15:23:31 GMT"); expect.add(null);
 inputs.add("01 May 2012 15:23:31 BLA"); expect.add(null);
 inputs.add("01 May 2012-15:23:31"); expect.add(null);
 inputs.add("01 May 2012-15/23:31"); expect.add(null);
 inputs.add("01 May 2012-15/23:31"); expect.add(null);
 for (int i = 0; i < inputs.size(); ++i) {
 Long expectTime = expect.get(i);
 Calendar output = RegexpPractice.parseDate(inputs.get(i));
 if (expectTime == null) {
 assertNull(String.format("Test %d failed: Parsing <<%s>> (should be null)", i, inputs.get(i)), output);
 continue;
 } else {
 assertNotNull(String.format("Test %d failed: Parsing <<%s>> (unexpected null)", i, inputs.get(i)), output);
 }
 output.set(Calendar.MILLISECOND, 0);
 long outTime = output.getTimeInMillis();
 assertEquals(String.format("Test %d failed: Parsing <<%s>> (was %s not %s)", 
 i, inputs.get(i), df.format(outTime), df.format(expectTime)), 
 (long) expectTime, outTime);
 }
 }
```

• πάντα ῥεῖ: I'd prefer to use the regex to match the particular weekday amd month names. That makes it a bit longer,, but better readable (semantically), and maybe even increases the performance of that function. Also leave case insensivity to the regex engine and setting it into case insensitive mode.
• Rika: do you think there is no way to shorten it? It's hardly readable for me this way, but I do want it to be efficient
• jessehouwing: WHY would you want to create a custom RegEx?! You can use a library like JodaTime to build the parser and have it spit out the RegEx. If you need to remove optional extra spaces a single `"\s+" => " '" replacement will fix those prior to parsing. programcreek.com/java-api-examples/…
• AJNeufeld: TimeZone.getTimeZone ("GTM")? Surely, you mean "GMT".
• Rika: added the tester, it's clear there what is the expected

Answer 1

You could utilize Named Capturing Groups that would clarify the meaning of capturing group in the regex, as well as the method calls in the matcher. furthermore, with Named Capturing Groups, you don't care about the order of the groups and don't need to "skip" captured groups that you do not want to read (like the time zone)

you could also break the regex into separate Strings for the capturing groups to further enhance readability:

String timeZoneRegex = "(?<timeZone>[A-Z][a-z][a-z],\\s+)";
String dayOfMonthRegex = "(?<dayOfMonth>[0-2][0-9]|[3][0-1])";
...
Pattern pattern = Pattern.compile(timeZoneRegex + "?" + dayOfMonthRegex + ...

instead of matcher.group(1) --> matcher.group("dayOfMonth");