Course – LS – All

Get started with Spring and Spring Boot, through the Learn Spring course:


1. Overview

In this tutorial, we’ll explore several ways to convert String objects into Date objects. We’ll start with the new Date Time API, java.time, that was introduced in Java 8 before looking at the old java.util.Date data type also used for representing dates.

To conclude, we’ll look at some external libraries for conversion using Joda-Time and the Apache Commons Lang DateUtils class.

Further reading:

Convert java.util.Date to String

Learn several methods for converting Date objects to String objects in Java.

Check If a String Is a Valid Date in Java

Have a look at different ways to check if a String is a valid date in Java

Convert Between String and Timestamp

Learn how to convert between String and Timestamp with a little help from LocalDateTime and Java 8.

2. Converting String to LocalDate or LocalDateTime

LocalDate and LocalDateTime are immutable date-time objects that represent a date, and a date and time, respectively. By default, Java dates are in the ISO-8601 format, so if we have any string which represents a date and time in this format, then we can use the parse() API of these classes directly.

Interested in working as a Java developer intern? Check out Jooble!

2.1. Using the Parse API

The Date-Time API provides parse() methods for parsing a String that contains date and time information. To convert String objects to LocalDate and LocalDateTime objects, the String must represent a valid date or time according to ISO_LOCAL_DATE or ISO_LOCAL_DATE_TIME.

Otherwise, a DateTimeParseException will be thrown at runtime.

In our first example, let’s convert a String to a java.time.LocalDate:

LocalDate date = LocalDate.parse("2018-05-05");

A similar approach to the above can be used to convert a String to a java.time.LocalDateTime:

LocalDateTime dateTime = LocalDateTime.parse("2018-05-05T11:50:55");

It is important to note that both the LocalDate and LocalDateTime objects are timezone agnostic. However, when we need to deal with time zone specific dates and times, we can use the ZonedDateTime parse method directly to get a time zone specific date time:

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z");
ZonedDateTime zonedDateTime = ZonedDateTime.parse("2015-05-05 10:15:30 Europe/Paris", formatter);

Now let’s have a look at how we convert strings with a custom format.

2.2. Using the Parse API With a Custom Formatter

Converting a String with a custom date format into a Date object is a widespread operation in Java.

For this purpose we’ll use the DateTimeFormatter class, which provides numerous predefined formatters, and allows us to define a formatter.

Let’s start with an example of using one of the predefined formatters of DateTimeFormatter:

String dateInString = "19590709";
LocalDate date = LocalDate.parse(dateInString, DateTimeFormatter.BASIC_ISO_DATE);

In the next example, let’s create a formatter that applies a format of “EEE, MMM d yyyy.” This format specifies three characters for the full day name of the week, one digit to represent the day of the month, three characters to represent the month, and four digits to represent the year.

This formatter recognizes strings such as “Fri,  3 Jan 2003″ or “Wed, 23 Mar 1994“:

String dateInString = "Mon, 05 May 1980";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("EEE, d MMM yyyy", Locale.ENGLISH);
LocalDate dateTime = LocalDate.parse(dateInString, formatter);

2.3. Common Date and Time Patterns

Let’s look at some common date and time patterns:

  • y – Year (1996; 96)
  • M – Month in year (July; Jul; 07)
  • d – Day in month (1-31)
  • E – Day name in week (Friday, Sunday)
  • a AM/PM marker (AM, PM)
  • H – Hour in day (0-23)
  • h – Hour in AM/PM (1-12)
  • m – Minute in hour (0-60)
  • s – Second in minute (0-60)

For a full list of symbols that we can use to specify a pattern for parsing click here.

If we need to convert java.time dates into the older java.util.Date object, read this article for more details.

3. Converting String to java.util.Date

Before Java 8, the Java date and time mechanism was provided by the old APIs of java.util.Date, java.util.Calendar, and java.util.TimeZone classes, which we sometimes still need to work with.

Let’s see how to convert a String into a java.util.Date object:

SimpleDateFormat formatter = new SimpleDateFormat("dd-MMM-yyyy", Locale.ENGLISH);

String dateInString = "7-Jun-2013";
Date date = formatter.parse(dateInString);

In the above example, we first need to construct a SimpleDateFormat object by passing the pattern describing the date and time format.

Next we need to invoke the parse() method passing the date String. If the String argument passed is not in the same format as the pattern, then a ParseException will be thrown.

3.1. Adding Time Zone Information to java.util.Date

It’s important to note that the java.util.Date has no concept of time zone, and only represents the number of seconds passed since the Unix epoch time – 1970-01-01T00:00:00Z.

However, when we print the Date object directly, it will always be printed with the Java default system time zone.

In this final example, we’ll look at how to format a date while adding the time zone information:

SimpleDateFormat formatter = new SimpleDateFormat("dd-M-yyyy hh:mm:ss a", Locale.ENGLISH);

String dateInString = "22-01-2015 10:15:55 AM"; 
Date date = formatter.parse(dateInString);
String formattedDateString = formatter.format(date);

We can also change the JVM time zone programmatically, but this isn’t recommended:


4. External Libraries

Now that we have a good understanding of how to convert String objects to Date objects using the new and old APIs offered by core Java, let’s take a look at some external libraries.

4.1. Joda-Time Library

An alternative to the core Java Date and Time library is Joda-Time. Although the authors now recommend that users migrate to java.time (JSR-310), if this isn’t possible then the Joda-Time library provides an excellent alternative for working with Date and Time. This library provides pretty much all the capabilities supported in the Java 8 Date Time project.

The artifact can be found on Maven Central:


Here’s a quick example working with the standard DateTime:

DateTimeFormatter formatter = DateTimeFormat.forPattern("dd/MM/yyyy HH:mm:ss");

String dateInString = "07/06/2013 10:11:59";
DateTime dateTime = DateTime.parse(dateInString, formatter);

Let’s also see an example of explicitly setting a time zone:

DateTimeFormatter formatter = DateTimeFormat.forPattern("dd/MM/yyyy HH:mm:ss");

String dateInString = "07/06/2013 10:11:59";
DateTime dateTime = DateTime.parse(dateInString, formatter);
DateTime dateTimeWithZone = dateTime.withZone(DateTimeZone.forID("Asia/Kolkata"));

4.2. Apache Commons Lang – DateUtils

The DateUtils class provides many useful utilities, making it easier to work with the legacy Calendar and Date objects.

The commons-lang3 artifact is available from Maven Central:


Let’s convert a date String into a java.util.Date using an Array of date patterns:

String dateInString = "07/06-2013";
Date date = DateUtils.parseDate(dateInString, 
  new String[] { "yyyy-MM-dd HH:mm:ss", "dd/MM-yyyy" });

5. Conclusion

In this article, we illustrated several ways of converting Strings to different types of Date objects (with and without time), both in plain Java as well as using external libraries.

The full source code for the article is available over on GitHub.

Course – LS – All

Get started with Spring and Spring Boot, through the Learn Spring course:

res – REST with Spring (eBook) (everywhere)
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.