Match dates in various formats with Java regular expressions

01 Oct 2023

RegularExpressions

Working with date inputs from users can be a common task in various Java applications. However, dates can be entered in different formats, making it challenging to validate and process them accurately. One approach to overcome this challenge is to use regular expressions (regex) to match and parse dates in various formats. In this blog post, we’ll explore how to use Java regular expressions to match dates in different formats.

Identifying Common Date Formats

Before diving into the regular expressions for matching dates, let’s identify some common date formats we may encounter. The following are a few examples:

MM/dd/yyyy (e.g., 12/25/2022)
dd-MM-yyyy (e.g., 25-12-2022)
yyyy-MM-dd (e.g., 2022-12-25)

These are just a few examples, and there can be numerous variations and additional formats. For brevity, we will focus on these three formats in our examples.

Using Java Regular Expressions to Match Dates

To match dates in various formats using regular expressions, we’ll utilize the Pattern and Matcher classes from the java.util.regex package in Java.

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

public class DateMatcher {
    public static void main(String[] args) {
        String inputDate = "12/25/2022";

        // Regex pattern to match MM/dd/yyyy format
        String regexPattern = "^\\d{2}/\\d{2}/\\d{4}$";
        
        Pattern pattern = Pattern.compile(regexPattern);
        Matcher matcher = pattern.matcher(inputDate);
        
        if (matcher.matches()) {
            System.out.println("Date format matched!");
        } else {
            System.out.println("Date format does not match.");
        }
    }
}

In the above example, we initialize a String variable inputDate with the date value we want to match. We then define the regular expression pattern using the desired format, which, in this case, is MM/dd/yyyy. The ^ and $ symbols mark the beginning and end of the string, respectively. \d represents any digit, and {2} indicates that there should be two digits.

Next, we compile the regex pattern using Pattern.compile() and create a Matcher object by calling pattern.matcher(inputDate). We can then use the matches() method on the Matcher object to check if the input date matches the specified format.

Extending the Example to Other Date Formats

To match other date formats, we can define additional regex patterns. Here’s an example of matching the dd-MM-yyyy format:

String regexPattern = "^\\d{2}-\\d{2}-\\d{4}$";

For the yyyy-MM-dd format, the pattern would be:

String regexPattern = "^\\d{4}-\\d{2}-\\d{2}$";

By creating multiple regex patterns and using them with the Matcher class, we can easily extend the code to match and validate dates in various formats.

Conclusion

Using Java regular expressions, we can efficiently match and validate dates entered in different formats. By defining regex patterns for each format, we can ensure that the user’s input adheres to the expected date format. This approach provides a flexible and scalable solution for handling date inputs in Java applications.

#Java #RegularExpressions