I have dates in text format of the form dd-mmm-yy or d-mmm-y, where months are abbreviations in letters (for example, 4-Nov-09 or 12-Dec-05, etc...) I would like to parse it to produce a java.util.Date object.
Could this be achieved by leveraging the java.text.DateFormat class? Or is there another easy way of doing this?
You may need to use the SimpleDateFormat for parsing custom formats. This article explains the details of formatting.
"d-MMM-yyyy" corresponds to 4-Nov-2009
SimpleDateFormat is the class normally used for this. Note that this class is not thread-safe (somewhat counter-intuitively) and if you're using this in a threaded context, then investigating Joda and its DateTimeFormatter is worthwhile.
You can do it with java.text.SimpleDateFormat. Click the link, you'll see all patterns.
For 1-2 digit days you can use the d pattern. For 3-character month abbreviations you can use the MMM pattern. For 2 digit years you can use the yy pattern.
So the following should do:
String dateString = "4-Nov-09";
SimpleDateFormat sdf = new SimpleDateFormat("d-MMM-yy");
Date date = sdf.parse(dateString);
Whatever you do, please use a Locale. That way, you'll still get reasonable results when the input comes in with a month name in French.
This is the modern answer. The DateFormat class mentioned in the question and its SimpleDateFormat subclass used in most of the old answers are notoriously troublesome and long outdated. Don’t use any of those. Don’t use Date either, it’s poorly designed and long outdated too.
Since you have got a two-digit year (09 and 05 in your examples), you need to decide on a century. In the first round I am assuming that the year is in the range 2000 through 2099.
First we need a formatter:
static DateTimeFormatter dateFormatter
= DateTimeFormatter.ofPattern("d-MMM-uu", Locale.ENGLISH);
DateTimeFormatter is thread safe, so we’re happy with one instance for all to use. @shoover is correct that we should provide a locale. Use the formatter like this:
String text = "4-Nov-09";
LocalDate date = LocalDate.parse(text, dateFormatter);
System.out.println("Date: " + date);
Output is:
Date: 2009-11-04
For validation, in particular of the correct interpretation of the two-digit year, I recommend that you add a range check. For example, to validate that the parsed date is not more than 10 years into the past or future:
LocalDate today = LocalDate.now(ZoneId.systemDefault());
if (date.isBefore(today.minusYears(10))
|| date.isAfter(today.plusYears(10))) {
System.err.println("This date can’t be right");
}
For many purposes you will know in advance that the date is either in the past or in the future and can narrow down the valid interval even further than in my example.
If the years can go outside the 20xx range, we control the interpretation of the year through a DateTimeFormatterBuilder and its appendValueReduced method. Refer to one of the related answers in the list of links below.
You could try this library dateparser.
It can recognize any String automatically, and parse it into Date, Calendar, LocalDateTime, OffsetDateTime correctly.
With it, you don't have to prepare any appropriate patterns:
Date date = DateParserUtils.parseDate("12-Dec-05");
The date will be Mon Dec 12 00:00:00 CST 2005
Is it cool?
